python

基础

a = input('输入')//input()返回的数据类型是str，需要进行转换
a = int(a)
print(a)

if a < 10:
	print(a)
elif a > 10 and a < 20:
	print(a)
else
	print(a)

//简单匹配
score = 'B'
match score:
    case 'A':
        print('A')
    case 'B':
        print('B')
//复杂匹配
age = 15
match age:
    case x if x < 10://当age < 10 成立时匹配，且赋值给x
        print(1)
    case 10:
        print(10)
    case 11 | 12 | 13://匹配多个值
    	print(11~13)
        
 
//循环
names = ['a','b']
for name in names:
    print(name)

sum = 0
for x in range(100):
    sum = sum + x
print(sum)

while n > 0:
    sum = sum + n
    n = n - 1
print(sum)

list

list：列表，一种有序的集合，可以随时添加和删除其中的元素

list元素的数据类型可以不同

list元素也可以是另一个listlist = [ 'a' , [1,2] ]

classmate = ['a','b','c']
len = len(classmate)//获取元素个数
s = classmate[0] //索引访问，下标从0开始
s = classmate[-1] //获取最后一个元素 
s = classmate[-2]//倒数第二个
classmate.append('d')//追加元素到末尾
classmate.insert(1,'g')//往索引为1的地方插入元素
classmate.pop()//删除末尾元素
classmate.pop(i)//删除索引为i的元素
classmate[1] = 'f'//修改元素

tuple

tuple也是有序列表，但是tuple一旦初始化就不能修改，代码更安全

1 2	t = (1,2) t = (1,)// ！只有一个元素是需要加一个逗号消除歧义

dict

字典，使用键值对存储

d = {'a': 1 , 'b': 2 ,'c': 3}
d['d'] = 4
print(d['a'])
d.get('a')//如果key不存在，则返回None
d.pop('a')//删除key，对应的value也会删除

函数

max可以接收任意多个参数，并返回最大的那个

时间

1 2	import time localtime = time.localtime(time.time())

获取格式化时间

1 2	import time localtime = time.asctime(time.localtime(time.time()))

格式化日期

1 2	import time print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()))

%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00-59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示

数据类型转换

int('123')
float('12.34')
str(1.23)
bool(1)//True
bool('')//False

定义函数

1 2	def my_x(x): return x

返回多个值

1 2	def move(x,y): return x,y

默认参数

def power(x,n=2)：
	s = 1
	while n > 0:
		n = n - 1
        s = s * x
    return s

可变参数

传入的参数的个数时可变的

def cal(numbers):
	sum = 0
	for n in numbers:
		sum = sum + n
	return sum

//调用时组装list或tuple
cal([1,2,3])
cal((1,2,3))

def cal(*numbers):
	sum = 0
	for n in numbers:
		sum = sum + n
	return sum

cal(1,2,3)//定义可变参数和定义一个list或tuple相比，仅仅在参数前面加了一个*号，可以传入0个参数

nums = [1,2,3]
cal(*nums)//可以在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去

关键字参数

关键字参数允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

def person(name,age,**kw):
	print('name':,name,'age',age,'other',kw)

person('a',1,gender='m',job = 'e')

高级特性

切片

取一个list或tuple的部分元素

a[0:3]表示从索引0开始取，知道索引3为止，但不包括索引3

a[-2：-1]表示从倒数第二个开始取，知道倒数第一个，但不包括倒数第一个

tuple也可以用切片操作，只是操作结果依旧是tuple

迭代

python中只要时可迭代对象，无论有无下标，都可以的迭代

d = {'a':1,'b':2}
for key in d:
	print(key)//迭代key
for value in d.values():
	print(value)//迭代value

字符串也是可迭代对象

for ch in 'abc':

对list实现下标循环

内置的enumerate函数可以把一个list变成索引—元素对

for i,value in enumerate(['a','b,'c]):
	print(i,value)
0 a
1 b
2 c

列表生成式

用来创建list的生成式

1 2	[x*x for x in range(1,11) if x % 2 == 0] [4,16,26,64,100]

1 2	[m+n for m in 'abc' for n in 'xyz'] ['ax','ay','az','bx'...]

dict 的 items()可以同时迭代key和value

for key,value in d.items():

if…else

[x for x in range(1,11) if x % 2 ==0]

不能在最后的if加上else，最后的if为筛选条件

[x if x % 2 == 0 else -x for x in range(1,11)]

[-1,2,-3,4,-5...]

if写在for前面必须加else，需要根据x计算记过，因为必须加上else

生成器 (generator)

把列表生成式的[]改成()

g = (x*x for x in range(10))

//打印g的每一个元素
 for n in g:
        print(n)

def fib(max):
	n,a,b = 0, 0 ,1
	while n<max:
		print(b)
		a,b=b,a+b
		n=b+1
	return 'done'

a,b=b,a+b相当于t = (b,a+b) a=t[0] b = t[1]

fib函数定义了斐波那契数列的推算规则，要把fib函数变成generator函数，只需要把print(b)改为yield b就可以了

def fib(max):
	n,a,b = 0,0,1
	while n<max:
		yield b
		a,b = b,a+b
		n=n+1
	return 'done'

迭代器

凡是可作用于for循环和next()函数的对象都是Iterable类型
集合数据类型如list,dict,str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象

函数式编程

高阶函数

map / reduce

map函数接收两个参数，一个是函数，一个是Iterable；map将传入的函数依次作用到序列的额每个元素，并把结果作为新的Iterator返回

def f(x):
	return x*x
r = map(f,[1,2,3,4])
list(r)//[1,4,9,16]
list(map(str,[1,2,3]))//['1','2','3']

reduce把一个函数作用在一个序列上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是

reduce(f,[x1,x2,x3]) = f(f(x1,x2),x3)

filter

filter接收一个函数和一个序列，把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素

sorted

排序算法

sorted([1,4,2],key=abs)

它可以接收一个key函数来实现自定义的排序

匿名函数

list(map(lambda x:x*x,[1,2,3]))

]关键字lambda表示匿名函数，冒号前面的x表示函数参数

偏函数

1 2	int('123') int('123',base=8)//转为8进制整数

面向对象编程

类和实例

类是抽象的模板，而实例是根据类创建出来的一个个具体的对象

class Student(Object)类名通常是大写开头的单词，括号里的是从哪个类继承下来的，一般使用object类

class Student(object):
	def  __init__(self,name,score):
		self.name = name
		self.score = score

_init_方法的第一个参数永远是self，表示创建实例本身

访问限制

实例的变量名如果以__开头，就变成了一个私有变量

class Student(object):
	def  __init__(self,name,score):
		self.__name = name
		self.__score = score

继承和多态

继承可以把父类的所有功能都直接拿过来，这样就不必重零做起，子类只需要新增自己特有的方法，也可以把父类不适合的方法覆盖重写

获取对象信息

type

判断对象类型

isinstance

判断对象类型，还可以判断class的继承关系

isinstance(d,Dogs)

还可以判断一个变量是否是某些类型中的一种

isinstance([1,2],(list,tuple))//true

isinstance((1,2),(list,tuple))//true

使用dir

要获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的 list

实例属性和类属性

直接在class中定义属性，这种属性是类属性，归类所有

class Student(object):
	name = 'Student'

print(Student.name)

面向对象高级编程

使用`slots`

限制实例的属性；比如只允许对Student实例添加 name 和 age 属性

1 2	class Student(object): __slots__ = ('name','age')

__slots__定义的属性仅对当前实例起作用，对继承的子类不起作用

多重继承

1 2	class Dog(Mammal,Runnable): pass

定制类

`str`

打印实例

class Stu:
	def __str__(self):
		return 'Stu object (name: %s)' % self.name
print(Stu('abc'))//Stu object (name: abc)

`iter`

一个类想被用于for in循环，就需要实现一个__iter__方法，该方法返回一个迭代对象，然后，py的 for 循环就会不断调用该迭代对象的__next__方法拿到循环的下一个值

class Fib(object):
    def __init__(self):
        self.a, self.b = 0, 1 # 初始化两个计数器a，b

    def __iter__(self):
        return self # 实例本身就是迭代对象，故返回自己

    def __next__(self):
        self.a, self.b = self.b, self.a + self.b # 计算下一个值
        if self.a > 100000: # 退出循环的条件
            raise StopIteration()
        return self.a # 返回下一个值

`getitem`

需要按照下标取出元素，需要实现__getitem__方法

class Fib(object):
    def __getitem__(self, n):
        a, b = 1, 1
        for x in range(n):
            a, b = b, a + b
        return a

f= Fib()
f[0] = 0
f[2] = 2

枚举类

from enum inport Enum
@unique//装饰器可以帮助我们检查保证没有重复值
Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'))

for name,menber in Month.__member__.items():
    print(name,member,member.value)//value属性默认从1开始计数
    
    
//访问
day1 = Month.Jan
day1 = Month['Jan']
day1v = Month.Jan.value
Month(1) = Month.Jan

错误、调试和测试

错误处理

try:
	...
execpt ...://发生不同类型的错误，应该由不同的except语句块处理
	...
finally://finally一定会执行
	...

IO编程

文件读写

读文件

f = open('/.../.../..txt','r')

f.read()一次读取文件的全部内容

f.close()文件使用完毕后必须关闭

try:
	f = open('/.../.../..txt','r')
	print(f.read())
finally:
	if f:
		f.close()
        
等价于：
	with open('/.../.../..txt','r') as f:
        print(f.read())

调用read会一次性读取文件的全部内存，如果文件过大，内存就爆了，因此在读取文件时，可以反复调用read(size)方法，每次最多读取 size 个字节的内容。另外调用readline()可以每次读取一行内容。

二进制文件

读取二进制文件，比如图片、视频等，用 rb 模式打开文件

f = open('/.../..jpg','rb)

写文件

写文件和读文件是一样的，区别主要是在open函数中需要传入标识符w或wb表示写二进制文件

写文件时不会立刻把数据写入磁盘，而是放到内存缓存起来，只有调用close()方法时，操作系统才保证把没有写入的数据全部写入磁盘

1 2	with open('/.../..txt','w') as f: f.write("hello")