python学习_python学习csdn-优快云博客

本文链接：https://blog.youkuaiyun.com/CheatMyself/article/details/139331187

python学习

1. 数据类型

1.1 Number类型

Python中的数值类型包括Int整型、Float浮点型、 Bool布尔型、Complex复数型

1.1.1 Int整型

Python3中不限制整数变量的取值范围

a= 1			# 正整数
b=-1			# 负整数
c=0b11			# 二进制表示的正整数
d=0x3A			# 十六进制表示的正整数
e=0o24			# 八进制表示的正整数

print(a,b,c,d,e)  #输出：1 -1 3 58 20

1.1.1.1进制转化

各种进制转换为10进制,使用int()函数进行转换,下面的例子为8进制转换为10进制

num = '0o12'
dec_num = int(num, 8)
print(dec_num)  # 输出：10

10进制转换为2进制

num = 10
bin_str = bin(num)
print(bin_str) 					 # 输出：0b1010

10进制转换8进制

num = 10
oct_str = oct(num)
print(oct_str)  # 输出：0o12

10进制转换16进制

num = 255
hex_str = hex(num)
print(hex_str)  # 输出：0xff

1.1.2bool型

布尔型，只有两个值，及True和False

a = False    #假
b = True     #真

1.1.3 float

浮点数,可以表示十进制或科学计数法，每个浮点数占8字节。浮点数通常有一个小数点和一个可选的后缀e(大写或小写，表示科学计数法)

a=1.789		#	普通小数
b=-40.		#  	相当于-40.0
c=3e-8		#   0.00000003
C=format(c, '.16f') #.16f表示保留16位小数
d=float("inf")		# 无穷大
e=float("nan")		#  非数值
print(a,b,c,C,d,e)  #输出：1.789 -40.0 3e-08 0.0000000300000000 inf nan
print(d>a)	 #输出：True

1.1.4complex

复数，复数由实数部分和虚数组成，虚数部分必须有后缀j或J

a = 85.65+3j
b = 0-236.4J
print(a,b)  #输出：(85.65+3j) -236.4j

1.1.5 操作符

1.1.5.1 算数操作符

操作符	含义
A + B	加或表示正数
A - B	减或表示负数
A * B	乘
A / B	除
A % B	取余
A ** B	幂操作：A的B次方
A // B	整除：只取整数部分
not A	取反操作：只用于bool类型
A>B	判读A是否大于B,结果为True或False
A

a = 5+3.5
b = 2 ** 3
c = 5 / 2
d = 5.0 / 2
e = 5.0 // 2
f = 10 % 3
g = not True
h = a==b
print(a,b,c,d,e,f,g,h)   #输出：8.5 8 2.5 2.5 2.0 1 False False

1.1.5.2 比特操作符

操作符	含义
~A	按照二进制取反；按照补码规则，结果数字是~(A+1)
A&B	并操作：只有对应的比特都为1时，对应的结果才为1，否则为0
A\|B	或操作：只有对应的比特有一个为1时，对应的结果才为1，否则为0
A^B	异或操作：两个对应的比特相同为0，否则为1
A>>B	右移：按照比特位右移（除以二）
A<<B	右移：按照比特位左移（乘以二）
A<<B	右移：按照比特位左移（乘以二）

a = ~30
b = 3 & 3
c = 3 & 1
d = 3 ^ 1
e = 3 << 1
print(a,b,c,d,e)  # 输出：-31 3 1 2 6

1.1.6 内置函数

1.1.6.1 通用函数

函数	含义
str(A)	将参数转化为可显示的字符串
type(A)	返回参数的对象类型
bool(A)	将参数转化为布尔类型
int(A)	将参数转化为整数类型，以十进制表达
float(A)	将参数转化为浮点类型
complex(A)	将参数转化为复数类型

a = str(0x20)
b = type(4.9)
c = type(True)
d = type(40+1J)
e = bool("True")
f = bool("2")
g = float("2.55")
h = complex("40+1J")
print(a,b,c,d,e,f,g,h)   # 输出：32 <class 'float'> <class 'bool'> <class 'complex'> True True 2.55 (40+1j)

1.1.6.2 特定函数

函数	含义
abs(A)	取绝对值
divmod(A,B)	取模操作：生成一个元组，形成(A除以B,A对B取余)这样一个元组
pow(A,B)	幂操作符：结果为“A的B次方”
round(A)	返回的参数四舍五入
oct(A)	将A转化为8进制
bin(A)	将A转化为2进制
chr(A)	将A转换为ASCII字符，要求0<=A<=255
ord(A)	chr(A)的反函数

a = abs(-3)  
b = pow(2,3)
c = divmod(5,2)
d = round(5.76445,3)
e = oct(10)
f = bin(5)
g = chr(255)
h = ord(g)

print(a,b,c,d,e,f,g,h)       #输出：3 8 (2, 1) 5.764 0o12 0b101 ÿ 255

1.2. Sequence类型

python的字符串(String)、元组(tuple)、列表(list)都属于序列类型。可以将字符串看作由字符组成的序列类型，元组是由任意对象组成的不可修改序列类型，列表是由任意对象组成的可修改序列类型。

1.2.1 操作符

操作符	含义
A[index]	获取序列中的第x个元素，index从0开始
A[index1:index2]	切片操作，获取序列中第(index1)到第(index2-1)个元素组成的子序列
A in B	判断B序列中是否有A,如果有则返回True,否则False
A not in B	判断B序列中是否没有A,如果有则返回True,否则False
A + B	链接A和B，生成新的序列并返回
A * number	将A重复number次，生成新的序列并返回
A>B	判断A是否大于B结果为True或False
A<B	判断A是否小于B结果为True或False
A==B	判断A是否等于B结果为True或False
A>=B	判断A是否大于等于B结果为True或False
A<=B	判断A是否小于等于B结果为True或False

a = "hello world,I am a string"
b = a[0]
c = a[0:1]
print(b,c)						#输出：h h
print(c==b)						 #输出：True
d = a[1:]
print(d)						#输出：ello world,I am a string

print(b in a)					#输出：True
print(b not in a)				#输出：False
e = ",I like python"
f = a + e
print(a+e)						#输出：hello world,I am a string,I like python
print("*"*10)					#输出：**********
g = [2,3,"apple",5] 			#输出：['apple', 5]
print(g[2:])					#输出：['apple', 5]

1.2.2 内置函数

函数	含义
enumerate(A)	对序列A生成一个可枚举对象，对象的每个元素都是一个二位元组，元组的内容为(index,item),即(索引号,序列元素)
len(A)	返回序列A的长度
list(A)	转换为list类型
max(A)	返回序列A中的最大元素
max(a,b,c...)	返回所有参数的最大元素
min(A)	返回序列A中的最小元素
min(a,b,c,...)	返回所有参数的最小元素
reversed(A)	生成A的反向序列迭代器
sorted(A,func=None,key=None,reverse=False)	对A排序，按照参数func、key、reverse指定的规则进行
sum(A,init=0)	对A中的元素求和
tuple(A)	转化为tuple

a = "hello world,I am a string"
b = enumerate(a)
print(b)
for index,item in b:
    print("index",index,"item",item)

a="dsajklj"
print(len(a))  #输出：7

a="dsajklj"
print(list(a))  #输出：['d', 's', 'a', 'j', 'k', 'l', 'j']

a="dsajklj"
print(max(a))  #输出：s

a = "zz"
b="www"
print(max(a,b))#zz

a=["a","v","d",'a',"dsa","w"]
for item in reversed(a):
    print(item)

a=["a","v","d",'a',"dsa","w"]
print(sorted(a))		#输出：['a', 'a', 'd', 'dsa', 'v', 'w']

x = [4, 6, 2, 1, 7, 9]
y = sorted(x, reverse=True)
print(y) # 输出：[9, 7, 6, 4, 2, 1]

x = [4, 6, 2, 1, 7, 9]
print(sum(x)) # 输出：29

x = [4, 6, 2, 1, 7, 9]
print(tuple(x))  # 输出：(4, 6, 2, 1, 7, 9)

1.2.3string与bytes

在python3中，string类型中的每个字符都以Unicode方式编码，因此实际上每个字符都可由多个字节组成。与string类型相对的是bytes(字节串)，它由若干个字节组成，以字节为单位进行操作。字节串用前缀b表示

print(b"Hello World".decode())	#输出：Hello World
print("Hello World".encode())	#输出：b'Hello World'

1.2.3.1基本使用

Python中的字符串使用单引号、双引号、三引号定义（单双都行）。其中三重引号用来定义多行文本。

a = "hello world"
b = 'hello world'
c = """hello world
        dasd
        dsad    
	"""

1.2.3.2字符串格式化

字符串格式化是指按照指定的规则链接、替换字符串并返回指定的字符串

老式	新式	解释
%c	{:c}	转为单个字符
%r	{!r}	转为用repr()函数表达的字符串
%s	{:s}或{!s}	转为用str()函数表达的字符串
%d or %i	{:d}	转为有符号的十进制数
%o	{:o}	转为无符号的八进制数
%x	{:x}	转为无符号的十六进制整数，十六进制字母用小写表示
%X	{:X}	转为无符号的十六进制整数，十六进制字母用大写表示
%e	{:e}	转为科学计数法表达的浮点数，其中e用小写表示
%E	{:E}	转为科学计数法表达的浮点数，其中E用大写表示
%f or %F	{:f}或{:F}	转为浮点数
%g	{:g}	由python根据数字的大小自动拍段转换为%e或者%f
%G	{:G}	由python根据数字的大小自动拍段转换为%E或者%F

辅助格式化符号

辅助格式化符号	解释
*	定义宽度或小数点的精度
-	左对齐
+	对正数输出正值符号"+"
<sp>	数字的大小不满足m,n的要求时，用空格补位
#	在八进制数前面显示零(0),在十六进制前面显示“0x”或者“0X”
0	数字大小不满足m.n要求时，用0补位
m.n	m是显示的最小总宽度，m是小数点的位数

charA = 65
charB = 66
print("ASCII码65代表:%c" %charA)   #ASCII码65代表:A
print("ASCII码%d代表:B" %charB)	#ASCII码66代表:B

print("%#x" %108)       				 #输出：0x6c
print("{1:#x}".format(1,108))			#输出：0x6c	

c = 1.5689
print("保留2位小数是%8.2f，字符宽度为8" %c)  				#输出：保留2位小数是    1.57，字符宽度为8
print("保留2位小数是{1:8.2f}，字符宽度为8".format(1,c))		#输出：保留2位小数是    1.57，字符宽度为8
print('Host:%s\t\t\t\tPort:%d' %('python',80))           #输出：Host:python				Port:80
print('MM/DD/YY=%02d/%02d/%d' %(2,1,96))				 #输出：MM/DD/YY=02/01/96
print("{} 是我最好的朋友，她{}岁了" .format("小明",'15'))	#输出：小明 是我最好的朋友，她15岁了
name = "小红"
age = "19"
print(f"{name}是我最好的朋友，她{age}岁了")				#输出：小红是我最好的朋友，她19岁了

1.2.3.3 转义字符

转义字符	解释	ASCII值
\a	响铃(BEL)	7
\b	退格(BS),将当前位置移到前一列	8
\f	换页(FF),将当前位置移到下页开头	12
\n	换行(LF),将当前位置移到下一行开头	10
\r	回车，将当前位置移到本行开头	13
\t	水平制表(HT)跳到下一个tab位置	9
\v	垂直制表(VT)	11
\\	代表一个反斜杠	92
\'	代表一个单引号'	39
\"	代表一个双引号	34
\?	代表一个?	63
\0	空字符	0

print("你好，\n 今天周五")
输出：你好，
	  今天周五
print(r"你好，\n 今天周五")   #r禁用转义字符
# 输出:你好，\n 今天周五

1.2.3.4内置函数

• capitalize()：将字符串中的第1个字符大写。
• center(width)：返回一个长度至少为width的字符串，并使原字符串的内容居中。
• count(str,beg=0,end=len(str))：返回子串str出现的次数，可以用开始索引（beg）和结束索引（end）指定搜索的范围。
• encode(encoding=‘UTF-8’,errors=‘strict’)：以encoding指定的编码格式编码string，返回一个bytes类型对象。
• endswith(obj, beg=0,end=len(string))b,e：检查字符串是否以obj结束，如果是，则返回True，否则返回False；可以用开始索引（beg）和结束索引（end）指定搜索的范围。
• expandtabs(tabsize=8)：把字符串string中的Tab符号转为空格，默认的空格数tabsize是8。
• find(str, beg=0,end=len(string))：检测str是否包含在string中；可以用开始索引（beg）和结束索引（end）指定搜索的范围，找到则返回索引值，找不到则返回-1。
• index(str, beg=0,end=len(string))：跟find()类似，但是如果str不在string中，则报一个异常。
• isalnum()：如果发现有一个字符并且所有字符都是字母或数字，则返回True，否则返回False。
• isalpha()：如果发现有一个字符并且所有字符都是字母，则返回True，否则返回False。
• isdecimal()：如果可解释为十进制数字，则返回True，否则返回False。
• isdigit()：如果可解释为数字，则返回True，否则返回False。
• islower()：如果字符串中的字符都是小写，则返回True，否则返回False。
• isnumeric()：如果只包含数字字符，则返回True，否则返回False。
• isspace()：如果字符串是空格，则返回True，否则返回False。
• istitle()：如果字符串是标题，则返回True，否则返回False。
• isupper()：如果字符串中的字符都是大写的，则返回True，否则返回False。
• ljust(width)：返回一个原字符串左对齐，并使用空格填充至长度width的新字符串。

• lower()：转换所有大写字符为小写。
• lstrip()：截掉string左边的空格。
• replace(str1, str2,num=count(str1))：把string中的str1替换成str2，num指定替换的最大次数。
• rfind(str, beg=0,end=len(string))：类似于find()，但是从右边开始查找。
• rindex( str, beg=0,end=len(string))：类似于index()，但是从右边开始查找。
• rjust(width)：返回一个原字符串右对齐并使用空格填充至长度width的新字符串。
• rpartition(str)e：类似于partition()函数，但是从右边开始查找。
• rstrip()：删除string字符串末尾的空格。
• split(str=“”, num=count(str))：以str为分隔符切片string，如果num有指定的值，则仅分隔num个子字符串。
• splitlines(num=count(‘\n’))：按照行分隔，返回一个包含各行作为元素的列表，如果num已指定，则仅切片num个行。
• startswith(obj, beg=0,end=len(string))：检查字符串是否以obj开头，如果是则返回True，否则返回False。可以用开始索引（beg）和结束索引（end）指定搜索的范围。
• strip([obj])：在string上执行lstrip()和rstrip()。
• swapcase()：翻转string中的大小写。
• title()：将字符串标题化，即所有单词都以大写开始，其余字母均小写。
• translate(str, del=“”)：根据str给出的表转换string的字符，将要过滤掉的字符放到del参数中。
• upper()：转换string中的小写字母为大写。
• zfill(width)：返回长度为width的字符串，原字符串string右对齐，前面填充0。

str="hello world"
print(str.center(18),"sdddsa")  #输出：   hello world     sdddsa

name = "Ada LovelAce"
print(name.title())		#输出：Ada Lovelace
print(name.upper())    #输出：ADA LOVELACE
print(name.lower())    # 输出：ada lovelace

1.2.4 元组

在python中，tuple的大小和其元素在初始化后就不能改变，tuple的操作速度比list的操作速度快。如果定义一个常量，需要不断的读取，则用tuple

tuple = ('你','是','18','岁')
print(tuple[2])  							#输出：18
print(tuple[1:])							#输出：('是', '18', '岁')
tuple2 = ('我','是','30','岁')	
tuple = tuple + tuple2						#可对元组重新赋值
print(tuple)								#输出：('你', '是', '18', '岁', '我', '是', '30', '岁')
print(len(tuple))							#输出：8

1.2.5列表

list的大小及元素在初始化中可以被再次修改

myList = ['你好',',','我','是','小','赵']
print(myList[2])		#我
print(myList[1:])		#[',', '我', '是', '小', '赵']
myList[5] = '张'
print(myList)			#['你好', ',', '我', '是', '小', '张']

print(len(myList))		#6

numList = [1,2,3,4,5,2,532,4234,321,35]
print(sorted(numList))	#[1, 2, 2, 3, 4, 5, 35, 321, 532, 4234]
print(numList)			#[1, 2, 3, 4, 5, 2, 532, 4234, 321, 35]    （不改变原数组）
print(sum(numList))		#5139

除了Sequence类型公用的操作，list类型还有一组自己的函数，常用的函数如下。
• append(obj)：在列表尾部添加一个对象。
• count(obj)：计算对象在列表中出现的次数。
• extend(seq)：把序列seq的内容添加到列表中。
• index(obj, i=0, j=len(list))：计算对象obj在列表中的索引位置。
• insert(index, obj)：把对象插入列表index指定的位置。
• pop(index=-1)：读取并删除index位置的对象，默认为最后一个对象。
• remove(obj)：从列表中删除对象obj。
• reverse()：获得反向列表。
• list.sort(func=None,key=None,reverse=False)：以指定的方式排序列表中的成员。

motorcycles = ['honda','yamaha','suzuki']
motorcycles.remove('honda')
print(motorcycles)  ##输出：['yamaha', 'suzuki']

numList = [1,2,3,4,5,2,532,4234,321,35]
print(numList.count(2))			#计算2在列表出现的次数   输出2

numList.insert(1,5)				# 输出：[1, 5, 2, 3, 4, 5, 2, 532, 4234, 321, 35]
print(numList)

myList = [1,3,1,4]
numList.extend(myList)			
print(numList)					#输出：[1, 5, 2, 3, 4, 5, 2, 532, 4234, 321, 35, 1, 3, 1, 4]

1.2.6set集合类型

Python中，通过关键字set和frozenset定义普通集合和不可变集合，普通集合可以省略set,直接用"{}"代替。

集合操作符:

操作符	解释
in	判断包含关系
not in	判断不包含关系
==	判断等于
!=	判断不等于
<	判断绝对子集关系
<=	判断非绝对子集关系
>	判断绝对超集关系
>=	判断非绝对超集关系
&	交运算
\|	并运算
-	差运算
^	对称差运算
\|=	执行并运算并赋值
&=	执行交运算并赋值
-=	执行差运算并赋值
^=	执行对称差运算并赋值

myList = [1,2,3,'English','0','python']
sample1 = set(myList)
sample2 = frozenset(['English','0','python'])

print(2 in sample1)                                     #输出：true
print(sample1 >= sample2)								#输出：True
sample3 = frozenset(['English','0','python','9'])		
print(sample1 - sample3)								#输出：{1, 2, 3}
print(sample1 & sample3)								#输出：{'English', '0', 'python'}
sample3 |= sample2		
print(sample3)											#输出：frozenset({'9', 'English', '0', 'python'})

set类型有一组自己的内置函数，用于集合的增、删、改等操作，frozenset为不可变集合，所以不行。
• add()：增加新元素。
• update(seq)：用序列更新集合，序列的每个元素都被添加到集合中。
• remove(element)：删除元素。

myList = [1,2,3,'English','0','python']
sample1 = set(myList)
sample1.add('JavaScript')
print(sample1)					#输出：{1, 2, 3, 'JavaScript', 'English', 'python', '0'}
sample2 = {5,'小明'}
sample1.update(sample2)
print(sample1)					#输出：{1, 2, 3, 'JavaScript', 5, 'English', 'python', '小明', '0'}
sample1.remove(1)			
print(sample1)					#输出：{2, 3, 'JavaScript', 5, 'English', 'python', '小明', '0'}

1.2.7字典（dict）类型

开发者使用{key:value,key:value…}表示

函数操作：
• clear()：清除字典中的所有键值对。
• copy()：复制字典的一个副本。
• fromkeys(seq,val=None)：用seq中的元素作为键创建字典，所有键的值都被设为val，val默认为None。
• get(key,default=None)：读取字典中的键key，返回该键的值；如果找不到该键则返回default所设的值。
• key in DICT：用in关键字判断键key在字典中是否存在，如果存在则返回True，否则返回False。
• items()：返回一个包含字典中键值对元组的列表。
• keys()：返回一个字典中所有键的列表。
• iteritems()：返回字典中所有键值对的迭代器。
• iterkeys()：返回字典中所有键的迭代器。
• itervalues()：返回字典中所有值的迭代器。
• pop(key[, default])：读取某键的值，并且从字典中删除该键的值。如果键key不存在且没有设置default，则引发KeyError异常。
• setdefault(key,default=None)：设置字典中键key的值为default。
• update(dict)：合并字典。
• values()：返回一个包含字典中所有值的列表

from datetime import datetime

dict1 = {'language':'python', 'name': '小明','Pages':445,'Title':'python学习'}
print(dict1['Title'])												#输出：python学习
dict1['date'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print(dict1)														#输出：{'language': 'python', 'name': '小明', 'Pages': 445, 'Title': 'python学习', 'date': '2024-02-26 14:03:15'}
dict1['language'] = 'java'
print(dict1)														#输出：{'language': 'java', 'name': '小明', 'Pages': 445, 'Title': 'python学习', 'date': '2024-02-26 14:03:15'}
print(dict1.values())							#输出：dict_values(['java', '小明', 445, 'python学习', '2024-02-26 14:10:45'])
print(dict1.get('Title','Todo'))				#输出：python学习
print(dict1.get('Author','Anonymous'))			#输出：Anonymous

2. 流程控制

2.1判断语句

条件判断是依据指定的变量或表达式的结果，决定后续运行的程序，最常用的是if-else指令，可以根据指定条件是否成立来决定后续的程序。也可以组合多个if-elif-else指令进行较复杂的条件判断。

import sys
param = None

if len(sys.argv) > 1:
    param = int(sys.argv[1])
if param is None:
    print("未输入参数")
elif param < -10:
    print('该数字小于-10')
else:
    print('该数字大于-10')

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

2.2循环语句

Python中的循环语句有两种形式：while语句和for语句。

myList = [1,2,3,4,5,6,7,8]
while len(myList):
    print(myList.pop())

myList = [1,2,3,4,5,6,7,8]
for i in myList:
    print(i)

开发逻辑较复杂的程序时，在while或for循环语句的循环体中，有时需要提前结束循环(break)，或者在本轮循环体尚未结束时提前开始下一轮循环(continue)，这就需要用到break及continue语句。

count = 0
while True:
    str = input("Enter quit:")
    if str == "quit":
        break
    count = count + 1
    print(count)
    if count%3 > 0:
        continue
    print("请输入quit")
print("结束循环")

3. 函数

在编程中使用函数可以写出优雅的程序结构，模块化的结构使程序简单化，并提高了可读性和可维护性。

def sum(a,b=5):
    return a+b

if __name__ == '__main__':
    print(sum(10,20))		#30
    print(sum(10))			#15

3.1变长参数

变长参数的函数即参数个数可变、参数类型不定的函数。设计一个参数个数可变、参数类型不定的函数，为函数设计提供了更大的灵活性。Python中允许定义两种类型的函数变长参数。
• 元组变长参数：适用于未知参数的数量不固定、但在函数中使用这些参数时无须知道这些参数的名字的场合。在函数定义中，元组变长参数用星号“*”标记。
• 字典（dict）变长参数：适用于未知参数的数量不固定、而且在函数中使用这些参数时需要知道这些参数的名字的场合。在函数定义中，字典变长参数用双星号“**”标记。

元组变长参数：

def show_message(message,*tupleName):
    for name in tupleName:
        print(message,"，",name)

if __name__ == '__main__':
    show_message("Good Morning","Jack","xiaoming","小李","小化","小黄")

输出：

Good Morning ， Jack
Good Morning ， xiaoming
Good Morning ， 小李
Good Morning ， 小化
Good Morning ， 小黄

字典变长参数:

from datetime import datetime
def check_book(**dictParam):
    if 'Price' in dictParam:
        Price = int(dictParam['Price'])
        if Price > 100:
            print("我想买这本书")
    print("这本书的信息如下：")
    for key in dictParam.keys():
        print(key, ':',dictParam[key])
    print("")

if __name__ == '__main__':
    check_book(authon='小明',Title='Economics Introduction')
    check_book(authon='小红',Title='Economics',Data=datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
    check_book(authon='小刚',Title='Economics Introduction',Data=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),Price=101)
    check_book(authon='小李',Title='小李好帅',Data=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),Price=11)

输出：

这本书的信息如下：
authon : 小明
Title : Economics Introduction

这本书的信息如下：
authon : 小红
Title : Economics
Data : 2024-02-26 21:13:51

我想买这本书
这本书的信息如下：
authon : 小刚
Title : Economics Introduction
Data : 2024-02-26 21:13:51
Price : 101

这本书的信息如下：
authon : 小李
Title : 小李好帅
Data : 2024-02-26 21:13:51
Price : 11

3.2 匿名函数

匿名函数（Anonymous Function）指一类无须定义标识符（函数名）的函数或子程序，普遍存在于多种编程语言中，一般用于只在代码中存在一次函数引用的场合

import datetime

print((lambda x,y: x*y+x*y)(2,3))

def nameFunc(name):
    return f"我的名字是".format(name)

def call_func(func,param):
    print(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
    print(func(param))

if __name__ == '__main__':
    call_func(nameFunc,"小红")			
    call_func(lambda x:x*2,9)
    call_func(lambda y: y * y, -4)

4. 异常

异常处理（又称为错误处理）功能提供了处理程序运行时出现的任何意外或异常情况的方法。Python异常处理使用try、catch、else和finally关键字来尝试可能未成功的操作、处理失败及正常情况，以及在事后清理资源

try:
    myList = [1,2,3,4,5,6,7,8]
    print(myList[10])       #超出索引会报错
except ZeroDivisionError as e:
    print("ZeroDivisionError 发生")
    print(e)
except (IndexError,EOFError) as e:
    print("超出索引")
    print(e)
except:
    print("未知错误")
finally:
    print("完成")

4.1自定义异常

定义了一个异常类MyError，异常类的__str__()函数可以用于设置本异常的字符串表达方式。主函数main()判断是否在启动程序时输入了命令行参数，如果没有输入参数则用raise关键字引发MyError异常

import sys


class MyError(Exception):
    def __str__(self):
        return "自定义错误"

def main():
    try:
        print("开始执行main函数")
        if len(sys.argv)==1:
            raise MyError()
        print("结束main函数")
    except MyError as e:
        print(e)

if __name__ == '__main__':
    main()

5. 对象

类是面向对象程序设计的核心概念，它是一种用户定义的引用数据类型。每个类都包含数据说明和一组操作数据或传递消息的函数。类的实例被称为对象。类有三大特性：封装性、继承性和多态性。封装性将数据和操作封装为一个有机的整体，增强了内部的高内聚性和与外部的低耦合性。继承性使得程序更易于理解，同时节省不必要的重复代码。多态性则允许同一操作作用于不同对象，产生不同的执行结果。在编程和面向对象设计中，类是一种抽象概念，代表了一类具有共同特征和行为的实体。通过类可以将具有相同属性和行为的对象进行分类和封装，使得我们可以通过类来操作和管理这些对象，而不必关心具体的细节。每个类都可以创建多个对象，这些对象共享类的属性和方法，但各自拥有独立的状态。

5.1以下是一个基本类

class MyClass(object):
    message = "Hello World!"
    
    def show(self):
        print(self.message)

类定义代码的解析如下。
• 类名为MyClass。
• 类中定义了一个成员变量message，并对其赋了初始值。
• 类中定义了成员函数show(self)，注意类中的成员函数必须要带参数self。
• 参数self是对象本身的引用，在成员函数体中可以引用参数self获得对象的信息。

5.2构造函数

构造函数是一种特殊的类成员方法，主要用来在创建对象时初始化对象，即为对象成员变量赋初始值。Python中的类构造函数用__init__命名，为MyClass添加构造函数方法，并实例化一个对象。

class MyClass(object):
    message = "Hello World!"

    def show(self):
        print(self.message)

    def __init__(self):
        print("创建构造函数")

inst = MyClass()
inst.show()

输出：

创建构造函数
Hello World!

class MyClass(object):
    message = "Hello World!"

    def show(self):
        print(self.message)

    def __init__(self,name='unset',color='block'):
        print("创建构造函数:",name,"",color)

inst = MyClass()
inst.show()

inst2 = MyClass("小明")
inst2.show()

inst3 = MyClass("小红","蓝色")
inst3.show()

inst4 = MyClass(color="蓝色")
inst4.show()

输出：

创建构造函数: unset block
Hello World!
创建构造函数: 小明 block
Hello World!
创建构造函数: 小红蓝色
Hello World!
创建构造函数: unset 蓝色
Hello World!

5.3析构函数

class MyClass(object):
    message = "Hello World!"

    def show(self):
        print(self.message)

    def __init__(self,name='unset',color='block'):
        print("创建构造函数:",name,"",color)

    def __del__(self):
        print("销毁对象")

inst = MyClass()
inst.show()

inst2 = MyClass("小明")
inst2.show()

del inst, inst2

inst3 = MyClass("小红","蓝色")
inst3.show()
del inst3

inst4 = MyClass(color="蓝色")
inst4.show()
del inst4

输出：

创建构造函数: unset block
Hello World!
创建构造函数: 小明 block
Hello World!
销毁对象
销毁对象
创建构造函数: 小红蓝色
Hello World!
销毁对象
创建构造函数: unset 蓝色
Hello World!
销毁对象

5.4实例成员变量

在构造函数__init__中定义了两个实例成员变量：self.name和self.color。在MyClass的成员函数（如本例中的show()函数和析构函数）中可以直接使用这两个成员变量，通过实例名也可以访问实例成员变量（如本例中的inst3.name）。

class MyClass(object):
    message = "Hello World!"
    def __init__(self,name='unset',color='block'):
        print("创建构造函数:",name,"",color)
        self.name = name
        self.color =color

    def show(self):
        print(self.message)
        print(f"{self.name} 喜欢 {self.color}")

    def __del__(self):
        print("销毁对象")

inst = MyClass()
inst.show()

inst2 = MyClass("小明")
inst2.show()

del inst, inst2

inst3 = MyClass("小红","蓝色")
inst3.show()
print(f"我也能调用{inst3.name}")
del inst3

inst4 = MyClass(color="蓝色")
inst4.show()
del inst4

创建构造函数: unset block
Hello World!
unset 喜欢 block
创建构造函数: 小明 block
Hello World!
小明喜欢 block
销毁对象
销毁对象
创建构造函数: 小红蓝色
Hello World!
小红喜欢蓝色
我也能调用小红
销毁对象
创建构造函数: unset 蓝色
Hello World!
unset 喜欢蓝色
销毁对象

5.5静态函数和类函数

静态方法：静态方法与类的实例无关，不需要访问实例中的属性或方法。静态方法没有默认的参数，也无法访问类中的属性或方法。静态方法可以通过类名或实例来调用。静态方法主要用于在类中定义一些独立的功能函数，与类的实例无关。 2. 类方法：类方法与类相关联，但可以访问和修改类的属性。类方法的第一个参数是类本身，通常被命名为“cls”。类方法可以通过类名或实例来调用。类方法则用于在类中定义与类相关的功能函数，可以访问和修改类的属性。总的来说，静态方法主要用于在类中定义一些独立的功能函数，与类的实例无关；而类方法则用于在类中定义与类相关的功能函数，可以访问和修改类的属性。

Python中支持两种基于类名访问成员的函数：静态函数和类函数，它们的不同点是类函数有一个隐性参数cls用来获取类信息，而静态函数没有该参数。静态函数使用装饰器@staticmethod定义，类函数使用装饰器@classmethod定义。

class MyClass(object):
    message = "我是message属性"
    def __init__(self,name="小明",color="红色"):
        print("构造方法被调用")
        self.name = name
        self.color = color

    def show(self):
        print(self.message)
        print(f"{self.name}说，他喜欢{self.color}")

    @staticmethod
    def printMessage():
        print("printMessage被调用")
        print(MyClass.message)

    @classmethod
    def createObj(cls,name,color):
        print("Object will be create:%s(%s,%s)"%(__name__,name,color))
        return cls(name,color)

    def __del__(self):
        print("对象销毁")

MyClass.printMessage()
inst = MyClass.createObj("Toby","red")
inst.show()
print(inst.message)
del inst

输出：

printMessage被调用
我是message属性
Object will be create:main(Toby,red)
构造方法被调用
我是message属性
Toby说，他喜欢red
我是message属性
对象销毁

5.6继承

类之间的继承是面向对象设计的重要方法，通过继承可以达到简化代码和优化设计模式的目的。Python在定义类时可以在小括号中指定基类，所有Python类都是object类型的子类

class Base(object):
    def __init__(self):
        print("俺是Base里的构造函数")

    def move(self):
        print("俺是Base函数里面的move方法")

    def __del__(self):
        print("对象销毁")

class subA(Base):
    def __init__(self):
        print("俺是subA里面的构造函数")

    def move(self):
        print("subA:重写了Base里面的move函数")

class subB(Base):
    def __del__(self):
        print("subB:销毁")
        super(subB, self).__del__()

instA = subA()
instA.move()
del instA

print('---------------------------')
instB = subB()
instB.move()
del instB

输出：

俺是subA里面的构造函数
subA:重写了Base里面的move函数

对象销毁

俺是Base里的构造函数
俺是Base函数里面的move方法
subB:销毁
对象销毁

• 定义了一个基类Base，基类继承自object，并且定义了构造函数、析构函数、成员函数move()。
• 定义了子类SubA，继承自Base类，定义、重载了自己的构造函数、成员函数move()。
• 定义了子类SubB，继承自Base类，定义、重载了自己的析构函数。析构函数中用super关键字调用基类的析构函数__del__()。
• 完成类的定义后，分别实例化了两个子类的对象，并调用了它们的move()方法和析构函数。

5.7多继承

Python中允许类的多继承，也就是一个子类可以有多个基类。

class BaseA(object):
    def move(self):
        print("我是BaseA里面的move")

class BaseB(object):
    def move(self):
        print("我是BaseB里面的move")

class BaseC(object):
    def move(self):
        print("我是BaseC里面的move")

class Sub(BaseC, BaseB):
    pass

inst = Sub()
inst.move()

输出:

我是BaseC里面的move

__(Toby,red)

构造方法被调用
我是message属性
Toby说，他喜欢red
我是message属性
对象销毁