web

# python

python基础语法

python ：解释性语言 编译型语言，进行编译一波，更接近底层，所以速度更快；

# python的基本数据类型

Number int float bool complex

判断数据类型的办法 type

type(3)
# <class 'int'>

两个整型相除，得到的是浮点型的结果

# 进制

  • 二进制 0b/0B开头
  • 八进制0o/0O开头
  • 十六进制0x/0X开头
转为二进制
bin(x)
转为八进制
oct(x)
转为十进制
int(x)
转为十六进制
hex(x)

# bool布尔类型

True False

type(True)===><class 'bool')

注意：True和False都是大写

complex复数

# 字符串 str

单引号 双引号单行 单双引号若要换行，则需要加“\”

如:'apple\
my love'

三引号多行

转义字符：

\n 回车
\r enter
\t 制表符

对付转义字符：

print("\\n")
print(r"\n")===>加r之后不是普通字符串了，而是原始字符串

# 字符串的运算

+拼接

“rrr111”*3===》rrr111rrr111rrr111

取字符串中具体的某一位或者某几位

"apple"[0]===>a
"apple"[-2]==>l

截取:左闭右开区间

"hello world"[0:5]===>hello 
"hello world"[6:11]===>world

默认大于11都可以得到字符串world，而且[6:]这种形式也能得到world

TIP

python中字符串和数字不能直接比较，与js不同。“3” 和3

# 列表 list

[1,2,3,4,5,6]
type([1,2,"ak"])
# <class list>

[[1,2],[3,4]===>别的语言叫二维数组，这里可以称呼为嵌套列表

去获取某项或者某几项与字符串基本一致。用[0]/[0:3]等等

如果用单一的索引去获得值，则是一个字符串，

而如果用两个值（有个值可以不写，加冒号在中间）则获得的身是一个数组。

len([1,2,3])
# 3 获得列表的长度

[1,2,3,4,5,6][0]
# 1 
[1,2,3,4,5,6][0:1]
# [1]

列表的加法和乘法和字符串类似，操作后会改变现有的列表。 列表添加一个元素的方法：

a=[1,2,3];
a.append(4);
a=[1,2,3,4];
a[len(a)]=5;(错误，报超出数组长度)

# 元组 tuple

（1，2，3） 基本和列表一致，但是，元组是不能改变的，一旦创建成功，后面的加乘等操作是不能改变它自身的元素。 不过元组里嵌套着列表，可以改变列表的值，因为列表是引用类型。

a=(1,2,[3]);
a[2][0]=[1,4];
a=====>(1,2,[1,4])
type(())==><class 'tuple'>
type((1))===><class 'int'>
type(("1"))===><class 'str'>

注意

为什么单一元组的出来的是其他类型呢，因为 小括号既可以是元组的符号，又是常用的计算运算符号 ，（运算优先级） 避免这种情况，当只有一个元素的元组，要在其后加上一个逗号。 (1,)

# 序列有哪些共有的操作（str list tuple）

  • 下标获值 "kkk113"[4];===>'1'
  • 截取 [1,2,3,4,5,6][0:2];===>[1,2]
  • 步长截取 (1,2,3,4,5,6,7,8,9,10)[0:10:2]===>(1,3,5,7,9) (1,2,3,4,5,6,7,8,9,10)[0::2]====>(1,3,5,7,9)
  • 加法和乘法
  • in运算符 'a' in 'abc'===>True
  • not in 1 not in [2,3]===>True
  • len方法求长度 len('1345')===>4
  • min和max
max((1,3,5,7,9,10,1,3,4))===>10
min("abcdj122")===>1

# 字母转ASII码方法

ord("a")==>97

# 集合 set 无序

type({1,2,3})==>set
  1. 集合是无序的，所以不支持下标和切片操作。
  2. 会自动去重
{1,2,3,1,2,4,5,1}===>{1,2,3,4,5}

可以用到的操作方法：

len({1,2,3,1,2,4,5,1})===>5(去重后的结果)

判断是否存在和不存在 in和not in

4 not in{1,2}===>True

去除集合中相应的值

{1,2,3,4}-{1}====》{2,3,4}(求两个集合的差集)
{1,2,3}-{1,2,4,5,6}====>{3}
{1,2}&{2,3}====>{2}(求两个集合的交集)
{1}&{2}====》set()
{1,2,3,1}|{4,5,6,1}===>{1,2,3,4,5,6}(求两个集合的并集)

如果创建的是个空集合，不能用{}表示，而是应该用set()表示。

# 字典 dict

很多key和value的集合，不是序列 type({1:1，2：2})====》<class 'dict'> 字典是不能有相同的键，第二个会把第一个给覆盖；

{"a":3,"b":4,"a":"5"}====> {'a': '5', 'b': 4}
{1:1,"1":2}["1"]===>2（字符串和数字1不一样）

# 序列的通用操作

序列分类：可变序列list 不可变序列tuple和str

[1]+[2,3]
#[1,2,3]

# 下标索引

a=[1,3,5,7]
print(a[-2])
# 5

索引可为负数，即从右往左数

# 切片和步长

a=(1,2,3,4,5,6,7,8)
print(a[1:-1])
print(a[0:])
print(a[0::1])
print(a[0:-1:1])
# (2, 3, 4, 5, 6, 7)
# (1, 2, 3, 4, 5, 6, 7, 8)
# (1, 2, 3, 4, 5, 6, 7, 8)
# (1, 2, 3, 4, 5, 6, 7)

# 长度和值运算

a=(1,2,3,4,5,6,7,1,1)
b='232141'
print(len(b))
print(a.index(7))
print(b.count("2"))
print(sum(a))
print(max(a),min(a))
# 6
# 6
# 2
# 30
# 7 1

str无法使用max min sum

count方法统计出现次数 index则是寻找出指定元素的下标值，没有这个元素会报错

# 运算符

# 变量名字

字母 数字 下划线（美元符号不行）

# 值类型和引用类型

  • 值类型：int str tuple(原值操作不可变，变了也就是另外开辟了一个地址，存了一个新的int str tuple)

  • 引用类型：list set dict id()函数查看内存地址。

      • / //(整除) **（乘方） 不支持自增运算符，自减运算符
> < == !=

[1,2,3]<[2,3,4]===>True 
[1,7,8]<[7,9]====>True
{1,4,5}<{2,3,1}====>False;集合无法判断

# 逻辑运算符

1 and 4=====>4
1 or 0=====>1
0 or 0=====>0
3>2 and 2>3=====>False
3>2 or 2>3=====>True
not(3>2)====>False
'a' or 'b'===> a
'a' and 'b'====>'b'
not 'a'===>False

# 成员运算符in（在） not in（不在）

1 in [1,4,5]====>True
1 in [2,3]====>False
1 not in [3]===>True

字典的成员运算符是取得key值名单

 'c' in{'c':1}===>True
3 in{"a":3}====>False

# 身份运算符 is is not

is和双等号是有区别的

a=1
b=1.0
a==b===>True(等号是比较值是否相等)
a is b===>False（is是比较身份是否相等【内存地址比较】）

a='1'

判断类型的函数isinstance（a,str）===>True

isinstance第二个参数可以接受一个元组，选择多个

b=3
isinstance(b,(int,str))===>True

# 流程语法

# if语句

if a:
	print("xxx")
	# else和elif

# 循环语句

a=5
while a:
    print("zzz")
    a-=1

# while可以与else连用
a=1
while a<10:
    a+=1
    print("zzz")
else:
    print("jieshu")

# for与for else

主要用来遍历数组等等操作

for a in arr:
	print(a)
	print(a,end="")不换行的操作

break和continue用法和js一致（加入了break后，不会执行for else中的else语句，continue会执行的）

python怎样实现其他语言的那种for循环呢？

for x in range(2,10):
	print(x)
# 2 3 4 5 6 7 8 9

# range

  • range(1,10,3)===>开始值为1，偏移量到10（不含10），步长为3.
  • range(10,1,-3)===>开始值为10，偏移量到1（不含1），步长为3.
  • 简单的话也可以通过b=a[0:len(a):2]===>不需要for循环就可以成功拿到相应的值。
arr=[1,3,4,5,6]
b=arr[0:len(arr):2]
print(b)
# [1,4,6]

# python 包和模块

  • 包（简单的理解为一个文件夹）（子包文件夹下的文件夹）
  • 模块（理解为一个个的文件，一个py文件）

python的包和模块的名字

包：一个文件夹想要变成一个包，下面必须具备一个__init__.py(可以空文件)

第一个方法：

import导入模块
import xxxxx
print(xxxxx.a)
import  xxxxx as k
print(k.a)

第二种方法：

from module import a
from t.c7 import a====》t文件夹下的c7文件中的变量a
from t.c7 import *====》默认是c7里所有的变量

注意

但是如果c7加了一个__all__=['a','b'],*则会只导入ab不导入其他的。

# 类和对象

类最基本的作用：封装 与在模块下编写的区别：

  1. 类下的函数一般称为方法；
  2. 类下面的函数参数括号里一定要加self
  3. 在函数内部要使用class里的变量，要加self.xxx

方法和函数的区别

  • 方法：设计层面（面向对象）
  • 函数：程序运行，过程式的一种称谓（面向过程）
  • 变量：如果是定义在模块称为变量，如果是定义在class类里的，则习惯称为数据成员。

类与对象

类：是现实世界或思维世界中的实体在计算机中的反映，它将数据以及这些数据的操作封装在一起。（行为与特征）抽象并不具体。

类被实例化之后，就变成了一个具体的对象。

构造函数不能强制返回任意的值

构造函数可以接受参数，初始化这个类的一些值。

类变量和实例变量

class Student():
    name=""=====》类变量
    age=""======》类变量
    def __init__(self,name,age): ====》构造函数：初始化
        self.name=name=====》实例变量
        self.age=age=======》实例变量
    def mes(self):==》实例方法：类的行为
        print(self.name)
        print(self.age)

student = Student('zhangsan',"18")

student.mes()

为什么当实例变量不存在时，如果该方法的有同名的类变量，就会采取往上寻找的方式。如果这个类也没有找到，它要是有父类的，可以继续往上层寻找。

实例方法如何获取类变量：

self.__class__xxx
或者
Student.xxx

class Student():
    name="11"
    def __init__(self,name):
        name=name
       
    def dream(self):
        print(self.name+"---")
student= Student("lisi")
print(student.name)====>11

类方法 @classmethods ====>装饰器 def plus_sum(cls):

class Student():
    name="11"
    sum=0
    def __init__(self,name):
        self.name=name
        self.__class__.sum+=1
        print(self.__class__.sum)
       
    def dream(self):        #self代表对象本身
        print(self.name+"---")
    @classmethod
    def lei(cls):            #代表类本身
        cls.sum+=2
        print(cls.sum)
student1= Student("lisi")  #1
student2= Student("lisi1") #2
student3= Student("lis2")  #3
Student.lei()             #5

类方法调用类变量更简单，而且调用方法时需要调用类而不是实例。

实例对象可以调用类方法如student1.lei();结果也是一样，但是不建议这样。逻辑上是有问题缺陷的。

静态方法：

@staticmethods
def add(x,y):   #不需要传入self、cls这种特定的参数
	pass

静态方法可以被对象或者类都可以调用。 静态方法可以调用类变量。

成员可见性（变量和方法的可见性）

内部调用 类内部一个函数可以调用另外一个函数

外部调用 是实例化后调用函数

公开的public

私有的private 方法和变量加了双下划线。就是私有的（前后都加双下划线就不会被认为是私有的了）

__dict__.

继承封装和多态（面向对象三大特性）

继承性

c6.py
class People ():
....
-----------------
c5.py
from c6 import People
class Student(People):
.....
------------------
import c6
class Student(c6.People):====>括号里的是父类的名
.....

class People():
   
    def __init__(self,age,name):
        self.age=age
        self.name=name
    def today(self):
        print("www")


class Student(People):
    def __init__(self,school,age,name):
        self.school=school
        People.__init__(self,age,name)  
#类调用实例方法（python的灵活性）

people1 =Student("延安小学",18,"zhangsan")
print(people1.name)
最后更新: 9/24/2019, 1:54:27 PM

python →