Python 03
小知识点的补充
a = 'alex'
b = 'alex'
print(a == b)
==是数值比较
必须得在终端去试is
a = 'alex@'
b = 'alex@'
print(a is b)---->False
print(id(a))--->id是测试对象的内存地址
print(id(b))
is 比较的是内存地址
小数据池：仅存在于str，int中，小数据池存在的意义就是为了节省内存
在一定范围之内的数字或字符串对n个相同的数据只开辟一个空间
int: -5---256
a=100
b=100
c=100
print(id(a),id(b),id(c))内存地址都是同一个
str:
1.不能含有特殊字符
2.单个元素*数字不能超过21
i = 'a'* 20
i1 ='a' *20
print(id(i),id(i1))
i = 'a'* 21
i1 ='a' *21
print(id(i),id(i1))内存地址不同了
编码二
ascii：数字，字母，特殊字符
字节：八位表示一个字节
字符：是你看到的内容的最小组成单位
abc --> a就代表一个字符
中国：中 就表示一个字符
a:0000 1011
unicode：万国码
起初： a :0000 1011 0000 1011
中：0000 1011 0000 1111
升级： a:0000 1011 0000 1011 0000 1011 0000 1011
中：0000 1011 0000 1111 0000 1011 0000 1111
unicode太占内存
utf-8：最少用8位表示一个字符
a:0000 1011
欧洲：0000 1011 0000 1011
亚洲中：0000 1011 0000 1011 0000 1011
gbk：国标，只有中文和英文
a:0000 1011
中：0000 1011 0000 1011 两个字节
gbk和utf-8中的英文都是用的ascii码
1.不同编码之间的二进制是不能互相识别的
2.对于文件的存储及传输不能是unicode的编码。（因为占用内存太多）
编码之间的转化：
python3x
str:在内部中的编码方式是unicode，所以str不能直接用于文件的存储和发送
int
bool
list
dict
tuple
bytes：str有的操作方法bytes都有，bytes内部编码方式是可设定的，但是是非unicode(utf-8,gbk,gb2312..)
字母：
str：表现形式：s1 = 'alex'
内部编码：unicode
bytes：表现形式：s2 = b'alex'
内部编码：非unicode
s1 = 'alex'
b1 = s1.encode('utf-8')
print(b1)
**************************************************
s1 = 'alex'
b1 = b'alex'
print(s1.capitalize())
print(b1.capitalize())
***************************************************************************8
中文：
str：表现形式：s1 = '中国'
内部编码：unicode
bytes：表现形式：b1 = b'\xe4\xb8\xad\xe5\x9b\xbd'(6个字节表示两个中文)
内部编码：非unicode
s1 = '中国'
b1 = s1.encode('utf-8')#转换成bytes类型
print(b1)
bytes和str之间的转换
str ---->bytes 使用encode编码
s1 = 'alex'
b1 = s1.encode('utf-8')
print(b1)
s1 = 'alex'
b2 = s1.encode('gbk')
print(b2)
bytes--->str decode解码，解码默认可以不写（以什么方式编码方式过来的，就用什么方式编码解码回去）
s1 = 'alex'
b1 = s1.encode('utf-8')
print(b1)
s2 = b1.decode('utf-8')#什么都不写是默认是utf-8
print(s2)
s2是str类型
s1 = 'alex'
b2 = s1.encode('gbk')
s3 = b2.decode('gbk')
print(b2)
print(s3)
**************************
utf-8和gbk对于字母来说引用的都是ascii码：例如以下不会报错
s1 = 'alex'
b1 = s1.encode('utf-8')
s2 = b1.decode('gbk')
print(s2)
但是对于中文会报错
s4 = '中国'
b4 = s4.encode('utf-8')
print(b4)
s5 = b4.decode('gbk')
print(s5)
utf-8的bytes类型转化为gbk的bytes类型（非字母）不能转
s4 = '中国'
b4 = s4.encode('utf-8')#utf-8的bytes类型
#转换成gbk的bytes类型
print(b4)
b6 = b4.decode('utf-8').encode('gbk')
print(b6)
集合
1.集合要求它里面的元素是可哈希的，元素不重复、无序。
但是集合本身是不可哈希的
set1 = {}
功能：
1.关系测试
2.去重
set1 = {'alex','wusir','taibai','alex'}
set2 = {'alex','wusir','taibai','alex',[1,2,3]}
print(set1)
print(set2)--->元素是可哈希的才行
列表去重，先变成集合然后在变成列表：
l1 = [1, 1, 2, 2, 3, 4, 4, 5]
print(list(set(l1)))
集合没有改：因为1.无序2.没有索引
增：
1.add
set1 = {'alex', 'wusir', 'ritian', 'egon', 'barry'}
set1.add('文周')
print(set1)--->每次打印顺序都会变
2.update相当于列表的extend
set1 = {'alex', 'wusir', 'ritian', 'egon', 'barry'}
set1.update('abc')
print(set1)
----->
{'ritian', 'alex', 'wusir', 'b', 'barry', 'c', 'egon', 'a'}
删：
pop随机删除
set1 = {'alex', 'wusir', 'ritian', 'egon', 'barry'}
set1.pop( )
print(set1)
remove按照元素去删
set1 = {'alex', 'wusir', 'ritian', 'egon', 'barry'}
set1.remove( 'alex')
set1.remove( 'alex1')元素不存在会报错
print(set1)
clear清空
set1 = {'alex', 'wusir', 'ritian', 'egon', 'barry'}
set1.clear()
print(set1)
----->
set()为了与空字典区分{}
del删除整个set
set1 = {'alex', 'wusir', 'ritian', 'egon', 'barry'}
del set1
print(set1)
查：只能用for循环去查
set1 = {'alex', 'wusir', 'ritian', 'egon', 'barry'}
for i in set1:
print(i)
关系测试：
set1与set2的交集：& intersection
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 & set2)
print(set1.intersection(set2))
并集 | union
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 | set2)
print(set1.union(set2))
差集 set1独有的元素就叫差集 - 和indifference
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 - set2)
print(set2 - set1)
print(set1.difference(set2))
反交集：^ symmetric_difference
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1 ^ set2)
print(set1.symmetric_difference(set2))
子集与超集
子集：
set1 = {1, 2, 3}
set2 = {4, 5, 1, 2, 3}
print(set1 < set2)
print(set1.issubset(set2))
超集：
set1 = {1, 2, 3}
set2 = {4, 5, 1, 2, 3}
print(set2 > set1)
print(set2.issuperset(set1))
集合是可变的数据类型
冻集合：变成不可变的集合
set1 = {1, 2, 3}
print(frozenset(set1))
------>
frozenset({1, 2, 3})
深浅copy
赋值运算共用一个内存地址：
s1 = [1, 2, 3]
s2 = s1
s1.append(666)
print(s1, s2)
----->
[1, 2, 3, 666] [1, 2, 3, 666]
浅copy：
s1 = [1, 2, 3]
s2 = s1.copy()
print(s2)
s1.append(666)
print(s1, s2)
------>
[1, 2, 3]
[1, 2, 3, 666] [1, 2, 3]
***********************************************
s1 = [1, 2, 3, [11,22]]
s2 = s1.copy()
s1[-1].append(666)
print(s1, s2)
print(id(s1), id(s2))
print(id(s1[-1]),id(s2[-1]))
--------->
[1, 2, 3, [11, 22, 666]] [1, 2, 3, [11, 22, 666]]
25172968 25173088
25171608 25171608
浅copy的机制：第一层各自独立，从第二层开始共用一个内存地址
深copy：
引用一个模块
import copy
s1 = [1, 2, 3, [11,22]]
s2 = copy.deepcopy(s1)
s1.append(666)
print(s1, s2)
-------->
[1, 2, 3, [11, 22], 666] [1, 2, 3, [11, 22]]
**********************************************************
import copy
s1 = [1, 2, 3, [11,22]]
s2 = copy.deepcopy(s1)
s1[-1].append(666)
print(s1, s2)
-------->
[1, 2, 3, [11, 22, 666]] [1, 2, 3, [11, 22]]
深copy：无论多少层，都是互相独立的。
切片：
先验证第一层：
s1 = [1, 2, 3, [11,22]]
s2 = s1[:]
s1.append(666)
print(s1, s2)
------>
[1, 2, 3, [11, 22], 666] [1, 2, 3, [11, 22]]
再验证第二层：
s1 = [1, 2, 3, [11,22]]
s2 = s1[:]
s1[-1].append(666)
print(s1, s2)
-------->
[1, 2, 3, [11, 22, 666]] [1, 2, 3, [11, 22, 666]]
所以切片是浅copy。
文件操作
护士主妇空姐嫂子联系方式.txt
文件路径path：d:......
编码方式encoding：gbk,utf-8......
操作方式mode：读，写，读写，写读，追加，改......
f1 = open('d:\护士主妇空姐嫂子联系方式.txt', encoding = 'utf-8', mode = 'r')
print(f1.read())
f1.close()
------->
读取出文件里的内容
"""
f1文件句柄,f,file,file_hander,f_h....
open（）调用的内置函数，内置函数调用的系统内部的open
一切对文件进行的操作都是基于文件句柄f1
执行流程：
1.打开文件，产生文件句柄
2.对文件句柄进行操作
3.关闭文件句柄
"""
报错原因：（总共两大类）
1.编码错误
UnicodeDecodeError: 'gbk' codec can't decode byte 0xab in position 2: illegal multibyte sequence
编码不一致
2.路径错误
SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 813-814: truncated \uXXXX escape
未转义
第一种方式： r'd:/护士主妇空姐嫂子联系方式.txt' 在路径最前面加一个r
第二种方式： 'd://护士主妇空姐嫂子联系方式.txt' 再加一个/
d:\护士主妇空姐嫂子联系方式.txt是绝对路径,log1是相对路径
记事本默认编码是gbk，notepad++和pycharm默认是utf-8
在同一个文件夹下创建一个文件，可以直接写文件名
f1 = open('log1', encoding = 'gbk', mode = 'r')
print(f1.read())
f1.close()
文件操作
读：r rb r+ r+b
写：w wb w+ w+b
追加：a ab a+ a+b
r+读模式加了一个写的功能
w+写模式加了一个读的功能
a+ 追加模式加了一个读的功能
rb以bytes类型读
读：
r模式 如果不写mode自动默认为r模式
1.read（）模式是全读出来：
f1 = open('log1', encoding = 'utf-8')
content = f1.read()
print(content)
f1.close()
rb模式 凡是带b的都是以bytes类型操作，操作的都是非文字类的文件
非文字类的读取要用rb模式。
图片的读取：使用bytes类型就没有编码方式了
f1 = open('1.jpg', mode ='rb')
print(f1.read())
f1.close()
以bytes类型读取
2.read(n)读一部分,n代表的是字符
f1 = open('log1',encoding = 'utf-8' )
content = f1.read(3)
print(content )
f1.close()
------->
打空格（读取3个字符）
r模式 read（n） n按照字符读取。
rb模式 read（n） n按照字节读取。
f1 = open('log1',mode= 'rb' )
content = f1.read(3)
print(content )
f1.close()
------->
b'\xe6\x89\x93'(三个字节，log1里面必须是中文)
要是读取4个字节，中文的话就是一个半，解码会报错,因为中文是3个字节：
f1 = open('log1',mode= 'rb' )
content = f1.read(4)
print(content.decode('utf-8'))
f1.close()
------->
会报错
b'\xe4\xb8\xb0\xe5' 四个字节没办法decode过来，一个半，因为一个中文需要三个字节，解码不回去
3.readline（） 按行读取，读一行，想读下一行再写一个readline（），然后空行也读，自动换行
f1 = open('log1',encoding = 'utf-8' )
print(f1.readline())
print(f1.readline())
f1.close()
4.readlines（）会把文件全读出来，每一个带一个换行符，放在一个列表中，列表的每一个元素就是文件中的每一行。
f1 = open('log1',encoding = 'utf-8' )
print(f1.readlines())
f1.close()
------->
['打空格发多少功夫大师多个\n', 'adfdsafasdf\n', '\n', 'dfasdfsadfasd\n']
5.for循环 f1叫变量也叫迭代器，迭代器在内存中只占一条，不占内存
f1 = open('log1',encoding = 'utf-8' )
for line in f1:
print(line)
f1.close()
w和a如果没有原文件，创建一个文件把内容写进去
a如果有原文件在原文件的最后面追加，加一个\换行符会另起一行追加
w如果有原文件，将原文件清空再把内容写进去
写：w
w模式对于没有原文件，新建文件写入内容
如果原来有log2这个原文件会先清空内容再写入新内容（不是覆盖）
f1 = open('log2',encoding = 'utf-8', mode = 'w' )
f1.write('老男孩 alex fsdjkfl')
f1.close()
f1 = open('log2',encoding = 'utf-8', mode = 'w' )
f1.write('taofd化开发地方')
f1.close()
wb模式：一切带b的不用写编码方式，一般用于非文字类的
先读取一个图片再写入，相当于复制：
图片的读取及写入
本地先有一个图片文件1.jpg
f1 = open('1.jpg', mode = 'rb' )
content = f1.read()
f2 = open('2.jpg', mode = 'wb')
f2.write(content)
f1.close()
f2.close()
追加 a
a没有文件，新建文件写入内容
f1 = open('log3', encoding = 'utf-8', mode = 'a')
f1.write('太白。。。')
f1.close()
------>新建log3写入以下
太白。。。
有原文件，在最后追加
f1 = open('log3', encoding = 'utf-8', mode = 'a')
f1.write('alex 666')
f1.close()
------->在log3里追加
太白。。。alex 666
另起一行追加：
f1 = open('log3', encoding = 'utf-8', mode = 'a')
f1.write('\nalex 666')
f1.close()
r+ 读写（与写读不一样），先读后写
f1 = open('log1', encoding = 'utf-8', mode = 'r+')
print(f1.read())
f1.write('666')
f1.close()
666加在了后面，因为文件操作里有个指针，先读指针会调到了最后，所以再写的话就加到了最后
先写后读就不一样了，666会加在最前面，因为光标默认在最前面，666覆盖最前面的字符，读出来的会从写完的那一个读到最后
f1 = open('log1', encoding = 'utf-8', mode = 'r+')
f1.write('666')
print(f1.read())
f1.close()
f1 = open('log1', encoding = 'utf-8', mode = 'r+')
f1.write('abc')
print(f1.read())
f1.close()
abc是三个字符也是三个字节，会直接覆盖掉一个中文字符，如果f1.write('a')就会报错
w+ 写读，先写后读
w会先清空后写，然后光标被调整到最后了f1.read()就读不出来了
f1 = open('log2', encoding = 'utf-8', mode = 'w+')
f1.write('快点发快递')
print(f1.read())
f1.close()
所以要调整光标：
f1 = open('log2', encoding = 'utf-8', mode = 'w+')
f1.write('快点发快递')
f1.seek(0)----->将光标调到最前
print(f1.read())
f1.close()
a+模式 先追加再读
f1 = open('log3', encoding = 'utf-8', mode = 'a+')
f1.write('python22期')
f1.seek(0)
print(f1.read())
f1.close()
其他操作方法：
read readline readlines write
readable()是否可读
f1 = open('log3', encoding = 'utf-8', mode = 'a+')
print(f1.readable())
f1.close()
writable()是否可写
f1 = open('log3', encoding = 'utf-8', mode = 'a+')
print(f1.writable())
f1.close()
tell()告诉我光标具体在哪
f1 = open('log2', encoding = 'utf-8')#log2中都是存的英文字符
f1.read(3)#光标在3的位置
print(f1.tell())
f1.close()
seek调整光标的位置
seek(0)将光标调整到开头
f1 = open('log2', encoding = 'utf-8')
f1.read(3)
print(f1.seek(0))
print(f1.tell())
f1.close()
--------->调整到最开始的位置
将光标调整到末尾是seek(0, 2)
f1 = open('log2', encoding = 'utf-8')
f1.read(3)
print(f1.seek(0,2))
print(f1.tell())
f1.close()
调整到任何一个位置：seek(n)
f1 = open('log2', encoding = 'utf-8')
f1.read(10)
f1.seek(f1.tell())
print(f1.tell())
f1.close()
f1 = open('log2', encoding = 'utf-8')
f1.seek( 12)
print(f1.tell())
f1.close()
truncate()截取文件，对原文件进行截取，按照字节对原文件截取，必须在a 或 a+ 模式（因为写模式会改变原文件，read模式只能读）
f1 = open('log3', encoding = 'utf-8', mode = 'a+')
f1.truncate(3)
f1.close()
为了免去每次不用关闭文件句柄，可以用with open
with open('log1', encoding = 'utf-8') as f1:#默认为r模式
print(f1.read())
1.不用主动关闭文件句柄
2.能用一条语句同时操作多个open
with open('log1', encoding = 'utf-8') as f1,\
open('log2', encoding ='utf-8', mode ='w') as f2:
print(f1.read())
f2.write('666666666')
with open('log1', encoding = 'utf-8') as f1:
print(f1.read())
pass
with open('log1', encoding ='utf-8', mode ='w') as f2:
f2.write('66666666')
以下会报错：
with open('log1', encoding = 'utf-8') as f1:
print(f1.read())
pass
with open('log1', encoding ='utf-8', mode ='w') as f2:
f2.write('66666666')
---------->
因为f1读了之后会对f1进行关闭，f1对log1进行了操作，在f1未关闭之前代码已经执行到了对f1的写操作，对log1产生了一个f2的文件句柄，共用一个文件句柄会产生错误，所以可以主动的去关闭
with open('log1', encoding = 'utf-8') as f1:
print(f1.read())
f1.close()
pass
with open('log1', encoding ='utf-8', mode ='w') as f2:
f2.write('66666666')
文件的改：
1.以读模式打开原文件
2.以写的模式打开一个新文件
3.将原文件内容读出，按照要求修改，将修改后的内容写入新文件
4.删除原文件
5.将新文件重命名原文件
例如：file中存放以下内容：
alex是老男孩python发起人，创建人。
alex其实是人妖。
谁说alex是sb？
你们真逗，alex再牛逼，也掩饰不住资深屌丝的气质。
将文件中所有alex都换成大写SB
比较low的方法：
import os#可以删除原文件
with open('file', encoding = 'utf-8') as f1,\#一下子全读出来了
open('file.bak', encoding = 'utf-8', mode ='w') as f2:
old_content = f1.read()#old_content的数据类型是字符串
new_content = old_content.replace('alex','SB')
f2.write(new_content)
os.remove('file')
os.rename('file.bak', 'file')
以下是比较高级的方法：
升级版本：
import os
with open('file', encoding = 'utf-8') as f1,\
open('file.bak', encoding = 'utf-8', mode ='w') as f2:
for line in f1:#读一行改一行
new_line = line.replace('SB','alex')
f2.write(new_line)
#w模式写一行会清空，但是w在for循环中写的动作是个持续性的写的过程，写始终没有停过，直到循环完毕，把所有内容写进去，才叫结束一次写的动作
#写模式一写就清空，但是在一个文件句柄里面可以写多次
os.remove('file')
os.rename('file.bak', 'file')
写模式一写就清空，但是在一个文件句柄里面可以写多次
with open('log1', encoding ='utf-8', mode='w') as f1:
f1.write('111')
f1.write('666')
f1.write('333')
f1.write('222')
在未关闭的文件句柄里都能写进去，关闭了文件句柄再写才会清空
函数
初识函数：
测试字符串的个数：
a = 'adsfdakfjasdlfj'
count = 0
for i in a:
count += 1
print(count)
测试列表的个数：
l1 = [1, 2, 3, 4, 5, 6]
count = 0
for i in l1:
count += 1
print(count)
重复代码多，可读性差
为了解决这两个问题，引进函数：
a = 'adsfdakfjasdlfj'
print(len(a))
------>引出函数概念：
s = 'adsfdakfjasdlfj'
def my_len():#这一步将函数名读到内存，函数体内内容不管
count = 0
for i in s:
count += 1
print(count)
my_len()#内存会立马进入函数体，执行里面的函数
"""
def 关键字 函数名():
函数体
函数执行，函数名（）
函数，以功能为导向。
"""
最好不要在函数体内用print()
s = 'adsfdakfjasdlfj'
def my_len():
count = 0
for i in s:
count += 1
print(my_len())
-------->
None
所以需要返回值return
return:
1.终止函数
def func1():
print(111)
print(222)
return
print(333)
func1()
--------->
111
222
2.给函数的执行者返回值。---->函数名（）
def func1():
print(111)
print(222)
return 666
ret = func1()
print(ret)
——————————>
111
222
666
"""
return 或者return None(什么都不写会返回一个None)
return单个值 是什么类型就返回什么类型
return多个值 会将多个值放到一个元组中，将元组返回给函数的执行者
"""
def func1():
return 'alex'
ret = func1()
print(ret,type(ret))
-------->
alex <class 'str'>
***************************************************
def func1():
return 'alex', 666, [1, 2, 3]
ret = func1()
print(ret,type(ret))
------>
('alex', 666, [1, 2, 3]) <class 'tuple'>
**************************************************************
s = 'lkfjsjulkjdgjdsf'
def my_len():
count = 0
for i in s:
count += 1
return count
print(my_len())
函数的传参：
函数的执行里面放的参数叫实参，函数的定义中的参数叫形式参数。
def my_len(argv):#形式参数，形参
count = 0
for i in argv:
count += 1
return count
s = 'lkfjsjulkjdgjdsf'
#mylen(s)#实际参数，实参
print(my_len(s))
********************************************************
def my_len(argv):
count = 0
for i in argv:
count += 1
return count
s = 'lkfjsjulkjdgjdsf'
l1 = [1, 2, 3, 4, 5]
print(my_len(l1))
1.形参角度
位置参数
默认参数
动态参数
位置参数：
def func1(a ,b, c):
print(a, b,c)
func1(1,2,'alex')
默认参数：
def login(name, sex):
with open('register',encoding ='utf-8',mode ='a') as f1:
f1.write('{},{}\n'.format(name,sex))
while True:
name = input('请输入姓名：').strip()
sex = input('请输入性别：').strip()
login(name,sex)
************************************************
为了避免重复一直写男，可以将形参写成默认参数：sex默认为男：
def login(name, sex='男'):#默认参数要在位置参数后面
with open('register',encoding ='utf-8',mode ='a') as f1:
f1.write('{},{}\n'.format(name,sex))
while True:
name = input('请输入姓名：').strip()
if '1' in name:
login(name)
else:
sex = input('请输入性别：').strip()
login(name,sex)
——————————————>
输入的时候前面带1就默认为男
动态参数：*args **kwargs 万能参数
args:所有的位置参数，放在一个元组中
kwargs：所有的关键字参数，放在一个字典中
def func3(*args,**kwargs):#函数定义的时候*代表聚合。
print(args)
print(kwargs)
func3(1,2,3,'alex',c=6,name='wiusir',age=21)
------------->
(1, 2, 3, 'alex')#args所有位置参数，放在一个元组中
{'c': 6, 'name': 'wiusir', 'age': 21}#kwargs所有关键字参数，并放在字典中
args和kwargs也可以用其他字母代替，但约定俗成是这两个。
def func3(*args,**kwargs):
print(args)
print(kwargs)
func3([1,2,3],(22,33))
--------->
([1, 2, 3], (22, 33))
{}
*****************************************************************
def func3(*args,**kwargs):
print(args)
print(kwargs)
func3(*[1,2,3],*(22,33))#函数的执行的时候，*代表打散，相当于变成了func3(1,2,3,22,33)
--------->
(1, 2, 3, 22, 33)
{}
def func3(*args,**kwargs):
print(args)
print(kwargs)
func3(**{'name':'alex'},**{'age':23})
--------->
()
{'name': 'alex', 'age': 23}
形参的顺序：位置参数，*args，默认参数，**kwargs
def func5(a,b,*args,sex='男',**kwargs):
print(a,b)
print(args)
print(sex)
print(kwargs)
****************************************************************************
def func2(*args,a,b):
print(args)
print(a,b)
func2(1,2,3,55,66)
#因为args会接收所有实参传过来的位置参数，导致后面的a,b永远也接收不到值，位置参数要一一对应，形参a,b没有接收到值，所以会报错，所以*args一定要放到位置参数后面
******************************************************
def func2(a,b,sex='man',*args):
print(a,b)
print(sex)
print(args)
func2(1,2,3,55,66)
------->
虽然没有报错但是导致默认参数没有意义，所以要把默认参数放到*args后面
def func2(a,b,*args,sex='man'):
print(a,b)
print(sex)
print(args)
func2(1,2,3,55,66,sex='女')
***************************************************8
def func2(a,b,*args,**kwargs,sex='man'):
print(a,b)
print(sex)
print(args)
print(kwargs)
func2(1,2,3,55,66,sex='女')#sex='女'是关键字参数，会被**kwargs收掉
改为：
def func2(a,b,*args,sex='man',**kwargs):
print(a,b)
print(sex)
print(args)
print(kwargs)
func2(1,2,3,55,66,sex='女',name='alex')
*************************************************
def func2(a,b,*args,sex='man',**kwargs):
print(a,b)
print(sex)
print(args)
print(kwargs)
func2(1,2,3,55,66,age=12,sex='女',name='alex')
-------->
1 2
女
(3, 55, 66)
{'age': 12, 'name': 'alex'}
2.实参角度
位置参数
关键字参数
混合参数
位置参数：按照顺序一一对应
def func1(a,b,c):#形参角度的位置参数必须与实参角度按顺序一一对应
print(a,b,c)
func1(1,2,'alex')#这三个参数叫位置参数
------>
1 2 alex
*****************************************************
def max(a,b):
if a > b:
return a
else:
return b
print(max(10,2))
上面可以用三元运算代替（对于条件简单运算结果简单的）
ret = a if a > b else b
def max(a,b):
ret = a if a > b else b
return ret
print(max(10,2))
*********************************************
如果函数体只有一句话的时候，函数体可以挪到上边：
def max(a,b):return a if a > b else b
print(max(8,99))
关键字传参：一一对应
def func2(a ,b):
print(a, b)
func2(b=2, a=3)#关键字传参不用在乎顺序
混合参数：（位置参数，关键字参数）
关键字参数必须要在位置参数的后面
def func3(a ,b, c, d):
print(a, b,c, d)
func3(1,2,5,d=3)
浙公网安备 33010602011771号