python基础

'''Number:
int\float\bool\complex
注：不可改变
type()\isinstance()认为子类是一种父类。
python3以后bool是int子类，True=1,False=0
判断：1 is True
四则运算：+、-、*、/（得浮点数）、//（得整数，注意不是整型）、%（取余）、**（乘方）
注：混合计算时，Python会把整型转换成为浮点数。
python支持的3种数值类型：
整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
数学函数：
floor、ceil、round、modf()
max()、min()、abs()
exp(x)、log()、log10()、pow(x,y)、sqrt(x)
注：math.log(math.e)=1,
math.log(100,10)=2,
math.exp(2)=e^2,
math.modf(-10.2)=-10,-0.2
随机函数:
range(start,end,step):按指定基数递增的集合中获取一个随机数，基数默认值为 1
random():随机生成下一个实数，它在[0,1)范围内。
choice(seq):从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
seed([x]):改变随机数生成器的种子seed。
shuffle(lst):将序列的所有元素随机排序。
uniform(x,y):随机生成下一个实数，它在[x,y]范围内。
三角函数：
sin()、cos()、tan()
asin()、acos()、atan()、atan2()
hypot(x,y):返回欧几里德范数 sqrt(x*x + y*y)。
degrees(x):将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x):将角度转换为弧度
常量：
pi、e
'''
a,b,c,d=1,1.1,True,1+2j;#complex(1,2)
print(type(a),type(b),type(c),type(d));
print(isinstance(a,int),isinstance(b,float),isinstance(c,bool),isinstance(d,complex));

'''String:
'',"",\
注：有序不可改变
索引：[]，0/-1
截取：[:],前闭后开。str[str_idx,end_idx],str_idx=0,1,...;end_idx=-1,-2,...(包含str_idx,不包含end_idx)
连接/更新：+
复制：*
删除：del list1[idex];del list1;
成员运算：in、not in
格式化：%
print("his name is %s, %d years old."%("mike,18"))
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x/%X 格式化无符号十六进制数/十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e/%E 用科学计数法格式化浮点数
%g/%G %f和%e/%E的简写
%p 用十六进制数格式化变量的地址
格式化辅助指令：
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号( + )
<sp> 在正数前面显示空格
# 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0 显示的数字前面填充'0'而不是默认的空格
% '%%'输出一个单一的'%'
(var) 映射变量(字典参数)
m.n. m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
str.format():Python2.6 开始新增了的格式化字符串函数
f-string： python3.6 之后版本添加的字面量格式化字符串语法。
name='mike';print(f'hi {name});print(f'{1+3}');
w = {'name': 'mike', 'age': '18'};print(f'{w["name"]}:{w["age"]}');
python3.8 之后:print(f'{1+2=}');#1+2=3
Python3中，所有的字符串都是Unicode字符串
转义：\（行中：转义；行尾：续行符），\加如下符号表示含义：
\、'、"：\、'、"
a:电脑响铃
000:空
n:换行
v:纵向制表符
t:横向制表符
r:回车，将 r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 r 后面的内容完全替换完成。
r:换页
yyy:八进制数，y 代表 0~7 的字符，例如：\接012 代表换行。
xyy:十六进制数，以 \接x 开头，y 代表的字符，例如：\接x0a 代表换行
反转义：r/R
字符串内建函数：
1 capitalize()：将字符串的第一个字符转换为大写
2 center(width, fillchar)：返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
3 count(str, beg= 0,end=len(string))：返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
4 bytes.decode(encoding="utf-8", errors="strict")：Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
5 encode(encoding='UTF-8',errors='strict')：以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
6 endswith(suffix, beg=0, end=len(string))：检查字符串是否以 suffix 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 suffix 结束，如果是，返回 True,否则返回 False。
7 expandtabs(tabsize=8)：把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
8 find(str, beg=0, end=len(string))：检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
9 index(str, beg=0, end=len(string))：跟find()方法一样，只不过如果str不在字符串中会报一个异常。
10 isalnum()：如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False
11 isalpha()：如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
12 isdigit()：如果字符串只包含数字则返回 True 否则返回 False..
13 islower()：如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
14 isnumeric()：如果字符串中只包含数字字符，则返回 True，否则返回 False
15 isspace()：如果字符串中只包含空白，则返回 True，否则返回 False.
16 istitle()：如果字符串是标题化的(见 title())则返回 True，否则返回 False
17 isupper()：如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
18 join(seq)：以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
19 len(string)：返回字符串长度
20 ljust(width[, fillchar])：返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
21 lower()：转换字符串中所有大写字符为小写.
22 lstrip()：截掉字符串左边的空格或指定字符。
23 maketrans()：创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24 max(str)：返回字符串 str 中最大的字母。
25 min(str)：返回字符串 str 中最小的字母。
26 replace(old, new [, max])：把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
27 rfind(str, beg=0,end=len(string))：类似于 find()函数，不过是从右边开始查找.
28 rindex( str, beg=0, end=len(string))：类似于 index()，不过是从右边开始.
29 rjust(width,[, fillchar])：返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
30 rstrip()：删除字符串末尾的空格或指定字符。
31 split(str="", num=string.count(str))：以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
32 splitlines([keepends])：按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
33 startswith(substr, beg=0,end=len(string))：检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
34 strip([chars])：在字符串上执行 lstrip()和 rstrip()
35 swapcase()：将字符串中大写转换为小写，小写转换为大写
36 title()：返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
37 translate(table, deletechars="")：根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
38 upper()：转换字符串中的小写字母为大写
39 zfill (width)：返回长度为 width 的字符串，原字符串右对齐，前面填充0
40 isdecimal()：检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。
'''
#字符串特殊字符
print('\a')#电脑响铃
print("\000")#空
print("\n")#换行
print("Hello \v World!")#纵向制表符
print("Hello \t World!")#横向制表符
print('google runoob taobao\r123456')#回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。
print("Hello \f World!")#换页
print("\110\145\154\154\157\40\127\157\162\154\144\41")#八进制数，y 代表 0~7 的字符，例如：\012 代表换行。
print("\x48\x65\x6c\x6c\x6f\x20\x57\x6f\x72\x6c\x64\x21")#十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行
#字符串换行、拼接、复制
print(r"this is a line with \n")
print("this is a line with \nyou are dog")
str1='he '+\
'is a dog'
print(str1)
print("i " "like " "that")
print("i "+"like "+"that")
print(("i " "like "+"that ")*2)
#字符串截取
print("you look smell good."[0])
print("you look smell good."[-1])
str3="you_are_beautiful!"
print("截取字符串:\n"+ str3[0:3]+"\n"+str3[1:7:2]+"\n"+str3[4:]+"\n"+str3[:-4]+"\n"+str3[0:]*2)
#函数的使用方法
print("".join(['m','a','c','a','l']))
print("YYYY-MM-DD HH24:MI:SS".translate(str.maketrans('YMDHIS','ymdhis','-: ')))
print("V"+"01928".rjust(7,'0'))

'''List:列表
注：0、元素有序可修改；1、元素类型可不同；2、可嵌套列表；3、可截取返回列表
索引：[]、0/-1
截取：前闭后开。list[str_idx,end_idx:step],str_idx=0,1,...,end_idx=-1,-2,...(包含str_idx,不包含end_idx),step:1/-1(步长,-1表逆向)
连接：+
复制：*
迭代：for i in list:print(i)
嵌套：[[],[]]
比较：operator.eq(lst1,lst2)
函数：len(列表),max(列表),min(列表),list(元组)
内置方法：
1 list.append(obj)：在列表末尾添加新的对象
2 list.count(obj)：统计某个元素在列表中出现的次数
3 list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4 list.index(obj)：从列表中找出某个值第一个匹配项的索引位置
5 list.insert(index, obj)：将对象插入列表
6 list.pop([index=-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7 list.remove(obj)：移除列表中某个值的第一个匹配项
8 list.reverse()：反向列表中元素
9 list.sort( key=None, reverse=False)：对原列表进行排序
10 list.clear()：清空列表
11 list.copy()：复制列表
'''
def reverseLaunage(s):
list1=s.split(" ");
list1=list1[-1::-1]
print(' '.join(list1))
if __name__=="__main__":
str0="He is a dog."
reverseLaunage(str0);

lst1=str0.split(" ")
lst1.reverse();
print(' '.join(lst1))

'''Tuple:元组
定义元组：tup1=();tup1=" ";tup1=('20',);tup1=('20','50')
注：0、元素有序不能修改，但能包含可变对象；1、元组类型可不同；2、可嵌套元组；3、可截取返回元组;
特注：元组中只有一个元素时，需加逗号（，），否则括号会被当运算符。
索引:[]
截取：前闭后开。tuple[str_idx,end_idx:step],str_idx=0,1,...,end_idx=-1,-2,...(包含str_idx,不包含end_idx),step:1/-1(步长,-1表逆向)
复制：*
连接：+
成员运算：in 、not in
迭代：for i in tup1:print(i,end=" ");
计数：len(tup1)
需改元组：非法
可通过创建新元组方式修改值。
删除元组：del tup1
内置函数：
1 len(tuple):计算元组元素个数。
2 max(tuple):返回元组中元素最大值。
3 min(tuple):返回元组中元素最小值。
4 tuple(seq):将可迭代系列转换为元组。
元组的不可变指的是：元组所指向的内存中的内容不可变。
'''
if type((50))==type((50,)):
print('true,type((50))=type((50,)):%s'%(type((50))))
else:
print('false,type((50)):%s,type((50,)):%s'%(type((50)),type((50,))))

tup1='1','2','3';dic1={id(tup1):tup1};
tup1='1','2';dic2={id(tup1):tup1};
if dic1.keys()==dic2.keys():
print('true,id:%s'%(list(dic1.keys())))
else:
print('false,%s:%s,%s:%s'%(list(dic1.keys())[0],list(dic1.values())[0],list(dic2.keys())[0],list(dic2.values())[0]))

'''Set:集合
由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能：是进行成员关系测试和删除重复元素。
注：0、元素无序可修改；1、空集合必须用set()创建，非空可用{para1,...},(para1...)
集合运算：
交集：A&B；并集：A|B；差集：A-B；补集：A^B
创建空集合：set()
创建非空集合：set(param)、{param}
内置函数：
set.add()
set.update(字符串|列表|元组|字典)
set.remove():移除元素。失败抛出异常
set.discard():移除元素。失败不抛异常。
set.pop():随机删除元素。对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
len(set)
set.clear()
i in set:判断元素是否存在
set.copy()：拷贝一个集合
set1.symmetric_difference(set2)：返回两个集合中不重复的元素集合。
set1.symmetric_difference_update(set2)：移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
set1.difference(set2):两个集合的差集set1-set2
set1.difference_update(set2):移除两个集合都存在的元素
set1.intersection(set2):交集
set1.intersection_update(set2):交集
set1.union(set2):并集
set1.isdisjoint(set2)：判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
set1.issubset(set2)：判断指定集合是否为该方法参数集合的子集。
set1.issuperset(set2)：判断该方法的参数集合是否为指定集合的子集
'''
print(set('abcdefghi')-set('abcdefjklm'))
print(set('abcdefghi')|set('abcdefjklm'))
print(set('abcdefghi')&set('abcdefjklm'))
print(set('abcdefghi')^set('abcdefjklm'))
#更新元组
set1=set(('mike','jack','julian'));set1.update(['ken','ann'],['jennie','lisa']);set1.add((1,2,3));print(set1)
set2={'mike','jack','julian'};set2.update(['ken','ann'],['jennie','lisa'],{1,2});print(set2)
#移除元素
set1.remove((1,2,3));print(set1);
set2.discard('mike');print(set2);
set2.pop();print(set2);
#拷贝集合
set3=set2.copy();print(set3)
#集合操作：交/并/补
print('交集：%s'%set1.intersection(set2));
print('并集：%s'%set1.union(set2));
print('差集：%s'%set1.difference(set2));
print('子集：%s'%set1.issubset(set2));
print('父集：%s'%set1.issuperset(set2));
if set1.isdisjoint(set2):
print('set1 = set2')
else:
print('set1 != set2')
'''Dictionary:
注：0、键值对间无序可修改；1、键必须是不可变类型；2、键必须唯一(可以为数字、字符串、元组)
dict.keys()
dict.values()
构造字典得方法：
dict[key]=value
dict=dict(zip(key_list,value_list))
dict([(key,value),(key,value)])
dict(a=1,b,2,c=3)
字典推导式：{x:x**2 for x in (1,2,3) if x>1}
迭代：for i in dict.values()/dict.keys()/dict.items():print(list(i))
删除：
del dic1['Name'] # 删除键 'Name'
dic1.clear() # 清空字典
del dic1 # 删除字典
内置函数：
len()
str()
type()
内置方法：
1 dict.clear()：删除字典内所有元素
2 dict.copy()：返回一个字典的浅复制
3 dict.fromkeys()：创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4 dict.get(key, default=None)：返回指定键的值，如果键不在字典中返回 default 设置的默认值
5 key in dict如果键在字典dict里返回true，否则返回false
6 dict.items()：以列表返回一个视图对象。（可以用list()将视图对象转为列表）
7 dict.keys()：返回一个视图对象。（可以用list()将视图对象转为列表）
8 dict.setdefault(key, default=None)：和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9 dict.update(dict2)：把字典dict2的键/值对更新到dict里
10 dict.values()：返回一个视图对象。（可以用list()将视图对象转为列表）
11 pop(key[,default])：删除字典 key（键）所对应的值，返回被删除的值。
12 popitem()：返回并删除字典中的最后一对键和值。
'''
dict1=dict.fromkeys(['1','2','3'],1)
print(dict1)
print(list(dict1.items()))
print({x:dict1.get(x) for x in dict1.keys() if x not in {'1'} })

'''数据类型转换：
隐式：1+1.2=2.2
显示：函数方法
函数方法：
int(x)：返回整数
float(x)：返回浮点数
complex(x,y)：创建一个复数
str(x)：返回字符串
list(s):序列转为列表
tuple(s):序列转为元组
set(s):序列转为可变集合
dict(d)：创建字典
char(x)\ord(x)：整数转字符/字符转整数
hex(x):整数转16进制
oct(x)：整数转8进制
repr(x):将对象 x 转换为表达式字符串
eval(str):用来计算在字符串中的有效Python表达式,并返回一个对象
frozenset(s)：转为不可变集合

'''

'''推导式：
功能：从一个数据序列构建另一个新的数据序列的结构体。
支持得数据结构：
list\dict\set\tuple
推导式：
1、列表：返回列表
[表达式 for 变量 in 列表]
[表达式 for 变量 in 列表 if 条件]
2、字典:返回字典
{键：值 for 变量 in collection}
{键：值 for 变量 in collection if 条件}
3、集合:返回集合
{表达式 for 变量 in 序列}
{表达式 for 变量 in 序列 if 条件}
4、元组：返回生成器对象,需要用tuple()转换一下
可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。
(表达式 for 变量 in 序列)
(表达式 for 变量 in 序列 if 条件)
'''
#列表
print([i for i in range(30) if i%3==0])
#字典
print({len(val):val for val in ['aaa','bbbb','ccc']})
#集合
print({x for x in 'abcdefghijklmnopqrstuvwsyz' if x not in 'acdobjiwupk'})
#元组
print(tuple(i for i in range(30) if i%3==0))

'''解释器：
Linux/Unix系统：默认python2.x版本，安装3.x版本在usr/local/python3下
添加环境变量：PATH=$PATH:/user/local/python3/bin/python3
查看版本：python --version
Windows系统：
设置环境变量：set path=%path%;D:\python3.x
交互式编程：linux
python3#启动解释器
在交互模式中，最后被输出的表达式结果被赋值给变量 _（只读变量）
脚本式编程：linux
python3 hello.py#方法1
方法2：脚本添加：#! /usr/bin/env python3
修改脚本权限：chmod +x hello.py
执行：./hello.py
'''

'''运算符：
算术运算符：+、-、*、/、%、//、**
比较（关系）运算符：==、！=、>、<、>=、<=
赋值运算符：=、+=、-=、*=、/=、%=、**=、//=、:=(v3.8+,海象运算if (n:=len(a)) > 10:print(f"List is too long ({n} elements, expected <= 10)"))
逻辑运算符：and、or、not
位运算符：&、|、^、~、<<、>>（与、或、异或、反、左移、右移）
成员运算符：in、not in(指定序列寻找值，返回bool)
身份运算符：is、not is(类似于id(x)==id(y)、id(x)!=id(y)，判断两个标识的引用是否是同一个对象，返回bool)
运算符优先级：
(expressions...),[expressions...], {key: value...}, {expressions...};圆括号的表达式
x[index], x[index:index], x(arguments...), x.attribute;读取，切片，调用，属性引用
await x；await 表达式
**；乘方(指数)
+x, -x, ~x；正，负，按位非 NOT
*, @, /, //, %；乘，矩阵乘，除，整除，取余
+, -；加和减
<<, >>；移位
&；按位与 AND
^；按位异或 XOR
|；按位或 OR
in,not in, is,is not, <, <=, >, >=, !=, ==；比较运算，包括成员检测和标识号检测
not x；逻辑非 NOT
and；逻辑与 AND
or；逻辑或 OR
if -- else；条件表达式
lambda；lambda 表达式
:=；赋值表达式
'''

'''流程控制语法
1,if..elif..else...

2,python3.10支持match
def switch(x):
match x:
case 1|2|3|4:
print(2)
case _:
print(-1)
switch(10)

3,while condition:...
4,while (false):...--无限循环，CTRL+C退出，适用于服务器响应客户端实时请求。
5,while codition:...else:...

6,for var in sequence:...else:...
7,range(n);range(start_idx,end_idx);range(start_idx,end_id,step);

8,关键字
break:跳出循环
continue:进入下次循环
pass:空语句，不做任何操作

9,迭代器
iter():返回一个特殊的迭代器对象， 这个迭代器对象实现了 __next__() 方法并通过 StopIteration 异常标识迭代的完成。
next():会返回下一个迭代器对象。
10,生成器：
调用一个生成器函数，返回的是一个迭代器对象。
注：在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

'''
#迭代器--返回数字的迭代器案例
# import sys
# class myIteration:
# def __iter__(self):
# self.a=1
# return self
# def __next__(self):
# if self.a<=6:
# x=self.a;
# self.a+=1;
# return x
# else:
# raise StopIteration
# iter1=myIteration()
# for i in iter(iter1):
# print(i,end=',')
# print('(for循环迭代)')#1,2,3,4,5,6,(for循环迭代)
# j,it=0,iter(iter1)
# while True:
# try:
# print(next(it),end=',')
# j+=1
# except StopIteration:
# print('(next()迭代)')#1,2,3,4,5,6,(next()迭代)
# sys.exit();
#生成器，生成Fibonacci数列
# def fibonacci(n):
# a,b,count=0,1,0
# while True:
# if count>n:
# return
# yield a
# a,b=b,a+b
# count+=1
# f=fibonacci(10)
# while True:
# try:
# print(next(f),end=" ")#1,0 1 1 2 3 5 8 13 21 34 55
# except StopIteration:
# sys.exit()

 

'''参数
0、可变&不可变参数：
(1):不可变:数值、字符串、元组
(2):可变:列表、字典、集合
1、关键字参数:使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
print(str='123')
2、默认参数:finction(param1,param2='123')
3、不定长参数:
(1)加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
(2)加了两个星号 ** 的参数会以字典(dict)的形式导入。
def functionname([formal_args,] **var_args_dict ):
"函数_文档字符串"
function_suite
return [expression]
(3)声明函数时，参数中星号 * 可以单独出现。*参数和其后参数会以字典(dict)的形式导入。
如果单独出现星号 *，则星号 * 后的参数必须用关键字传入：
'''
#可变&不可变参数
def change1(a):
a=10
print(id(a))#1860071168
def change2(l):
l.append([i for i in [10,2,3]])
return
a=1
print(id(a))#1860070880
change1(a)
a=1
print(id(a))#1860070880

l=[1,2,3];print(l);#[1, 2, 3]
change2(l);print(l);#[1, 2, 3, [10, 2, 3]]

#不定长参数 * 、 **
def printArgs(arg1="default",*vartuple):
print("arg1=",end="");print(arg1,end=",")
print("vartuple=",end="");print(vartuple)
printArgs("5",1,2,3,4)#arg1=5,vartuple=(1, 2, 3, 4)
printArgs("5") #arg1=5,vartuple=()
printArgs()#arg1=default,vartuple=()

def printArgs2(arg2="default",**vartuple2):
print("arg2=",end="");print(arg2,end=",")
print("vartuple2=",end="");print(vartuple2)
printArgs2("5",a=1,b=2,c=3,d=4);#arg2=5,vartuple2={'a': 1, 'b': 2, 'c': 3, 'd': 4}
#注，这种参数传递可以确定参数位置
printArgs2(a=1,b=2,c=3,d=4);#arg2=default,vartuple2={'a': 1, 'b': 2, 'c': 3, 'd': 4}
printArgs2("5") #arg2=5,vartuple2={}
printArgs2()#arg2=default,vartuple2={}

def printArgs3(arg3="default",*,vartuple3):
print("arg3=",end="");print(arg3,end=",")
print("vartuple3=",end="");print(vartuple3)
#*后参数vartuple3必须以关键字导入
printArgs2('5',A=0,B=1,C=2,vartuple3=2);#arg2=5,vartuple2={'A': 0, 'B': 1, 'C': 2, 'vartuple3': 2}
printArgs2("5")# arg2=5,vartuple2={}
printArgs2()# arg2=default,vartuple2={}

'''匿名函数
Python 使用 lambda 来创建匿名函数。
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
语法：lambda [arg1 [,arg2,.....argn]]:expression
lambda 只是一个表达式，函数体比 def 简单很多。
lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数。
虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++ 的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

(2)在函数中封装匿名函数。
我们可以将匿名函数封装在一个函数内，这样可以使用同样的代码来创建多个匿名函数。

(3)强制位置参数
Python3.8 新增了一个函数形参语法 / 用来指明函数形参必须使用指定位置参数，不能使用关键字参数的形式。
在以下的例子中，形参 a 和 b 必须使用指定位置参数，c 或 d 可以是位置形参或关键字形参，而 e 和 f 要求为关键字形参:
def f(a, b, /, c, d, *, e, f):
print(a, b, c, d, e, f)
f(10, 20, 30, d=40, e=50, f=60)
'''
func1=lambda x:x+1
func2=lambda x,y:x+y
print('func1(1)=%s'%func1(1))#2
print('func2(1,2)=%s'%func2(1,2))#3
import math
def mylambdafunc(n):
return lambda x:math.pow(x,n)
obj2=mylambdafunc(2)
obj5=mylambdafunc(5)
print('3的2次方：%s'%obj2(3))#9.0
print('3的5次方：%s'%obj5(3))#243.0

'''数据结构
(1)列表：区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改。
注意：类似 insert, remove 或 sort,reverse 等修改列表的方法没有返回值。
list.append(x) 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L) 通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x) 在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x) 删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i]) 从列表的指定位置移除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被移除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear() 移除列表中的所有项，等于del a[:]。
list.index(x) 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x) 返回 x 在列表中出现的次数。
list.sort() 对列表中的元素进行排序。
list.reverse() 倒排列表中的元素。
list.copy() 返回列表的浅复制，等于a[:]。

(2)列表当作堆栈：先入后出
栈顶增加元素：list.append(x)
栈顶删除元素：list.pop()

(3)列表当作队列：先入先出
队尾增加元素：list.append(x)
队头删除元素：list.pop(0)（删除效率不高，因为列表整体前移）
from collection import deque
queue=deque(['mike','jack','niki'])
queue.append('zack')
queue.popleft()
print(quque)#['jack','niki','zack']

(4)列表推导式:
列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。
每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。
这里我们将列表中每个数值乘三，获得一个新的列表：
lis=[1,2,3]
new_lis=[3*x for x in lis if x!=1]
print(new_lis)#[6, 9]

lis=[1,2,3]
new_lis1=[[x,x**2] for x in lis if x!=1]
print(new_lis1)#[[2, 4], [3, 9]]

lis2=['2022-12-12 11:16:59','2022-11-11 11:17:00','2023-01-28 11:16:59']
new_lis2=[i.replace('-','') for i in lis2]
print(new_lis2)

import re
lis2=['2022-12-12 11:16:59','2022-11-11 11:17:00','2023-01-28 11:16:59']
new_lis2=[re.sub('[- :]','',i).format('%Y%m%D%H%M%S') for i in lis2]
print(new_lis2)#['20221212111659', '20221111111700', '20230128111659']

lis3=[2,4,5];lis4=[1,3,6];
new_lis3=[x*y for x in lis3 for y in lis4];
print(new_lis3);#[2,6,12,4,12,24,5,15,30]
new_lis4=[x[i]*y[i] for i in range(len(lis3))];
print(new_lis4);#[2,12,30]

#列表推导式可以使用复杂表达式或嵌套函数：
lis5=[str(round(355/113, i)) for i in range(1, 6)]
print(lis5)#['3.1', '3.14', '3.142', '3.1416', '3.14159']

(5)删除列表元素
del 语句从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。
del a[1:2]#删除一个切割
del a[:]#清空整个列表
del a#删除对象

(6)遍历
#遍历字典键&值
for k,v in dict1.items()
#遍历序列下标&值
for idx,val in enumerate(lis1)
#遍历2个序列(如果有对应关系也可以变为字典dict(zip(lis1,lis2))遍历)
for l1,l2 in zip(lis1,lis2)
#顺序遍历序列
for i in sorted(set(lis1))
#反序遍历序列
for i in revsered(set(lis1))
'''
lis0=[[1,2,3,4],[5,6,7,8],[9,10,11,12]]
print([lis0[j] for j in [i for i in range(len(lis0))]])#[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
print([[s[i] for s in lis0] for i in range(len(lis0)+1)])#[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
lis1=[]
for i in range(len(lis0)+1):
row=[]
for s in lis0:
row.append(s[i])
lis1.append(row)
print(lis1)#[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
del lis0,lis1

#遍历字典键&值
dict1={'name':'niki','sex':'male','class':'Chihuahua dog'}
for k,v in dict1.items():
print('my %s is %s'%(k,v))
del dict1
#遍历序列下标&值
lis1=['小美','大壮','佛伯乐']
for idx,val in enumerate(lis1):
print('{0}是第{1}名'.format(val,idx+1))
del lis1
#遍历2个序列
lis1,lis2=['小美','大壮','佛伯乐'],['XM','DZ','FBI'];
for l1,l2 in zip(lis1,lis2):
print('%s代号%s'%(l1,l2))
#顺序遍历序列
for idx,val in enumerate(sorted(lis2)):
print(idx,val)
#反序遍历序列
for idx,val in enumerate(reversed(lis2)):
print(idx,val)
del lis1,lis2;

'''模块
Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为模块。
模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。
模块可以被别的程序引入，以使用该模块中的函数等功能。这也是使用 python 标准库的方法。
1、import sys 引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法。
2、sys.argv 是一个包含命令行参数的列表。
3、sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。

(1)模块与参数
#!/usr/bin/python3
#file.py
import sys
print('命令行参数如下:')
for i in sys.argv:
print(i)
print('\n\nPython 路径为：', sys.path, '\n')

$python3.6 file.py para1,para2
命令行参数如下:
file.py
para1
para2
Python 路径为： ['/root', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']

(2)模块与方法
#!/usr/bin/python3.6
#filename:func_module.py
def func1(param1):
print(%s, hello world!'%param1)
return
#!usr/bin/python3.6
#filename:test.py
#method1
import func_module
func_module.func1('niki')
#method2
from func_module import func1
func1('niki')
#method3
func= func_module.func1
func('niki')

(3)dir() 函数
内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回.
如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称。

(4)标准模块
有些模块会被直接构建在python解析器中,如sys。
sys.ps1\sys.ps2对应可修改的主副提示符:'>>>'/'...'
'''

'''sys与搜索路径sys.path
一个模块不论import多少次,在执行代码时只会被导入一次。
Python 解释器通过import查找对应文件的逻辑：
搜索路径是在 Python 编译或安装的路径，由一系列目录名组成的,Python 解释器就依次从这些目录中去寻找所引入的模块。
也可以通过定义环境变量的方式来确定搜索路径。
搜索路径被存储在 sys 模块中的 path 变量，做一个简单的实验，在交互式解释器中，输入以下代码：
import sys
print(sys.path)#['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload', '/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']
注1：第一项是空串 '',代表当前目录即执行python解释器的目录。
若像在当前目录下存在与要引入模块同名的文件,则当前目录下文件优先被搜索到。
注2：可以在脚本中修改sys.path来引入一些不在搜索路径中的模块。

'''

'''包
管理Python命名空间,采取"点模块名称"。如:某方法是A.B.C,代表A包下B模块的方法C。
优点:
1、包模块间方法,变量重名不受影响。
2、将特定功能集成到包中可实现功能复用。
3、包中必含__init__.py文件,方便__main__程序运行时搜索路径。可以是空文件，或初始化__all__变量。
4、__all__变量可定义包下可用子包,精确的包索引增加程序检索效率。但需保证开发者及时更新。
包导入方法：
1、导入包中特定程序：
1)import pack1.item1.program1
2)from pack1.item1 import program1
区别:前者使用全名pack1.item1.program1调用方法;后者直接使用程序program1调用
2、导入包中特定定方法/类/变量：
1)import pack1.item1.program1.func1
2)from pack1.item1.program1 import func1 as pro1_func1
注:当前包中不可出现与2)func1同名方法,同名必须设置别名
3、从包中调入*
缺点:大小写不敏感系统使用效率差,需要精确的包索引;可读性降低
优点:不与程序中导入*下特定模块冲突
4、__all__变量:设定时可使包导入特定模块
__all__=["program1","program2"]
5、导入兄弟包:
在program1.func1中导入program2.func1:from pack1.program2 import func1 as func2_1
6、__main__主模块:
主模块应当使用绝对路径
7、__path__属性:
目录列表。里面每一个包含的目录都有为此包服务的__init__.py,因此需在其他__init__.py被执行前定义。
修改此变量可用于影响包含在包里的模块和子包。适用于扩展包内模块。
'''

'''输入与输出
Python输出值方式：
1、表达式
2、print()
3、文件对象write()(标准输出文件可欧阳那个sys.stdout)
格式化输出：
str.format()
处理输出结果：
repr():解释器易读
str():用户易读
注:
# repr() 函数可以转义字符串中的特殊字符
hello = 'hello, runoob\n'
hellos = repr(hello)
print(hellos)#'hello, runoob\n'
# repr() 的参数可以是 Python 的任何对象
repr((x, y, ('Google', 'Runoob')))#"(32.5, 40000, ('Google', 'Runoob'))"
输入:
s=input('please input sth:')
print(s)
读写文件:
file1=open(filename,mode)
mode:
r(default):只读,指针在文件开头
rb/r+/rb+:b代表二进制格式,+代表打开文件从文件开头读写,b+代表二进制打开文件从开头读写
w:写入,已存在文件打开开头覆盖编辑;不存在文件创建编辑
wb/w+/wb+:...
a:追加,已存在文件打开结尾追加编辑;不存在文件创建编辑
ab/a+/ab+:...
解释:
打开方式:
只读：r
只写：写入方式：删除写w;追加写a
读写：写入方式：删除写w+;追加写：开头追加r+;结尾追加a+
'''
#两种方式输出平方与立方:数值全部右对齐

'''method1
rjust()\ljust()\center():对齐方式,空格填充
zfill()：0填充
'''
for i in range(1,11):
print(repr(i).rjust(2),repr(i*i).rjust(3),repr(i*i*i).rjust(4))
'''method2
{数字}:代表位置
{关键字参数}:代表参数名
'''
for i in range(1,4):
print('{0:2d} {1:3d} {2:4d}'.format(i,i*i,i*i*i))

#一个很长的格式化字符串, 在格式化时通过变量名而非位置。传入一个字典, 然后使用方括号 [] 来访问键值 :
table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; Taobao: {0[Taobao]:d}'.format(table))
del table
#Runoob: 2; Google: 1; Taobao: 3

#也可以通过在 table 变量前使用 ** 来实现相同的功能：
table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
del table
#Runoob: 2; Google: 1; Taobao: 3

#读写文件
# file1=open('helloworld.py','r')
# for i in file1:
# print(i)
#创建写
# file2=open('wzx_test.txt',mode='w+',encoding='utf-8')
# file2.writelines('this is a good world,\nthis is a bad world.')
# for i in file2.readlines:
# if i:
# print(i)
# else:
# print(i)