python杂记3.0

1.

三种序列和集合字典等换行不加/，
一般的print之类要加
三重引号出除了引号里面换行不加/，还可以用来注释
分号可以把很多缩进相同的逻辑行变成一行物理行，

索引：

－n到－1
0到n－1

绝对值之和为n

2.python集合

Python集合
集合方法:
1.add 添加一个不可变数据，就是一个普通元素到集合里
2.update 添加一个集合到原来的容器中，会自动解包再添加
集合的添加方法都不会添加相同的元素
3，del 直接删除整个集合
4.pop随机删除一个元素
5.remove按元素值删除指定元素，一个值本来就只可能有一个元素在里面，所以只会删除一次，但是如果那个元素本来就没在里面了，会报错
6，discard和remove差不多，只是就算没有那个元素，也不会报错
7，in这个在三种序列集合字典等容器迭代器里应该都能用来按照值查找元素并返回对应的位置
元组不能被偏移量索引修改
8.函数len()得到集合中元素的个数
9，clear清空集合
10.difference和减号可以返回两个集合的差集
11普通的集合等似乎不会出现可变数据类型那个加等于和等于加区别的问题
12用&符号或者intersection方法取两个集合交集
13使用方法copy()复制集合

Python 集合 set的使用-CSDN博客

Python学习之集合常用方法_python 集合 方法-CSDN博客

【精选】Python集合(set)的操作方法汇总(约20种操作方法),并附示例代码_python set操作_昊虹AI笔记的博客-CSDN博客

3.python列表

1，按位插入insert
2.尾加append普通元素，extend加列表
3.del 列表名加索引
或者pop(索引)删除，pop会返回这个被删除的值
4.remove按值删除
5.直接索引修改或者查找返回
6.对自身彻底排序用sort方法，里面reverse的布尔值默认False，也就是从小到大排序，反之就反之
还可以用系统sorted函数对这个列表产生一个被排序好的副本，本身没排序，不知道传引用进去做参数会如何
还可以直接reverse方法直接倒排序一下
7.len函数可获取列表等容器长度
8.和集合一样，可直接加起来可直接数乘重复，可用in查找判断，可用for迭代，
9.max最大值，min最小值，count统计元素出现次数，clear清空，
10和集合一样也有copy函数拷贝，
11.index获取某元素索引

Python中列表与集合_列表和集合的区别-CSDN博客

【Python】Python列表基本操作_python列表的基本操作-CSDN博客

python之列表（列表的所有操作）详细！！！_python列表命令-CSDN博客

4.python元组

1.元组很多东西和列表一样，不过创建时如果有元素就一定要逗号
2.元组本身不能排序，但可以作为sorted函数的可被解包的参数，返回的当然不是元祖，是列表
3.可以用元祖作为函数返回值，可以不要括号，来返回多个元素，也可以用lambda表达式返回函数，来当多级函数

python中的元组操作详解_python中元组的用法-CSDN博客

5.Python字符串

1.replace以旧换新，还能指定换几个，也可用于删除空格
2.split默认用空格分割，也可以指定符号分割，往往返回的是以字符串为元素的列表
3.strip删除字符串前后两边的空格，lstrip是删左边，rstrip是右边

Python字符串介绍详解_python 字符串 {}_坚果的博客的博客-CSDN博客

【精选】Python之字符串_python 字符串_发呆的魚的博客-CSDN博客

Python之字符串的基本操作（很详细）_python字符串操作-CSDN博客

Python正则表达式中字符串结尾匹配模式及元字符“$”介绍_python正则匹配最后一个字符_普通网友的博客-CSDN博客

6.python字典

1，列表，集合，字典等可变数据类型对象不能作为键；而数字，字符串，元祖都可以
2.字典只能通过键来修改，获取，删除或者增加值，键是唯一的，但不同的键可以对应同样的值，值可以是任意数据类型对象
3添加键值对可以直接加，删除要用del
4.clear清空键值对
5用get方法索引键，来获取值，如果没有这个键不会报错，返回none，直接用键会报错
6可用update来更新键值对的值，或者添加键值对
7.items返回键值对应组成的元祖组成的列表
keys返回所有的键作为元素组成的列表
values就是返回所有的值作为元素组成的列表
8.pop用键指定删除键值对并返回
9.dict.fromkeys用参数作为键，默认none为值，这个可以改的，去创建字典
10.len方法返回键总数
11.字典的items方法变成可迭代容器的问题，
zip函数除了位置匹配迭代，能否关键字匹配迭代，zip函数返回的是zip类型的可迭代容器，是通过两个容器映射成的，可以通过for循环元组位置匹配解包直接获取里面的映射zip类型 元素
zip类型如何输出

5字典的遍历_conch0329的博客-CSDN博客

【精选】Python字典使用教程：Python字典常用操作方法_python字典的基本操作_让你五行代码的博客-CSDN博客

7.strip方法去除字符串两边空格额原理，

分别是移除左右两边、左边、右边的字符 char。默认移除空白（空格、制表符、换行符）。

 注意：指定的符号的从重复符号也会被删除

Python:字符串中的方法--strip()_python strip多个_edward_zcl的博客-CSDN博客
字符串join只要是一边是字符串，另一边只要是可迭代对象就可以？

8.Python生成式笔记

列表生成式去掉括号和循环式就变成“结果生成式”（三元表达式），可以用作函数的返回值
在其余4种生成式中，结果式加循环式加条件判断式是一般的结构，还可以把条件判断式移到结果式中，也就是ifelse结构（三元表达式在生成式中的运用）

def function1(i):

    return i if i%2==0 else 0
    #分号可以把多个逻辑行变成一个物理行，三元表达式或者说结果生成式可以把多个逻辑行编程一个逻辑行，这两边的结果还可以是元组之类的容器

# for i in range(10):
#     print(function1(i))
#

list1=[1,2,3,4,5,6,7,8,9]
result=[i if i%3 is 0 else None for i in list1 if i%2 is 0]
print(result)
#这个是把一般的列表推到式左边的结果式编程一个三元表达式，充分说明这个列表推导式执行顺序就是：先循环式再条件判断式后结果式
#三元表达式还可以在左右边的值中进行嵌套，由外到内执行
age=20
#元组条件表达式
print(("250","38")[age>=18])#左假右真
#字典条件表达式
print({False:"250",True:"38"}[age>=18])#左假右真

python杂记2.0-CSDN博客

zip函数返回值zip对象可以直接for循环迭代

a=[1,2,3,4,5]
b=[6,7,8,9,10]
c=zip(a,b)
print(c)

for i,q in c:
    print(i, q)
"""

1 6
2 7
3 8
4 9
5 10
"""



# for i in c:
#     print(i)
# """
# 
# (1, 6)
# (2, 7)
# (3, 8)
# (4, 9)
# (5, 10)
# """

9.python解包打包

通俗解释：

打包：将多个物品装到一个袋子里，说白了就是聚合元素

解包：将一个袋子里的物品放到多个不同袋子中，说白了就是离散元素

for循环遍历以及那些获取元素前提都是系统解包，然后我们也可以手写离散性的解包，或者星号解包

python手动实现可迭代对象的打包、解包

打包：多个以逗号分隔的值（可以是不同类型）赋给一个变量时，多个值会被打包成一个元组类型赋值给变量

解包：将可迭代对象中的元素依次赋值给多个变量，左侧变量数==可迭代对象的元素个数，否则会报ValueError

# 打包：手动将元素打包成元祖
a = 1,2,3  # a为(1,2,3)
 
# 解包
x, y, z = a   # x=1,y=2,z=3
x, y, z = [1, 2, 3]    # x=1,y=2,z=3
x, y = {'a':1,'b':2}    # x=a,y=b 默认将字典的key赋值给变量
x, y = {'a':1,'b':2}.items()    # x=('a', 1) ,y=('b', 2)
x, y = 'hg'    # x=h,y=g
    
# 可迭代对象包含的元素和前面待赋值变量数量不一致，会报错
x, y = a  # 报错：ValueError: too many values to unpack (expected 2)   包里解压太多元素
x, y, z, o = a  # 报错：ValueError: not enough values to unpack (expected 6, got 5)  包里没有足够元素可以解压

*对可迭代对象进行打包/解包

# 打包
x, *y = [1, 'ttt', 66]
print(x, y)  # x=1,y=['ttt', 66]
x, *y = {'a': 1, 'b': 2, 'c': 3}
print(x, y)  # x=a,y=['b', 'c']
x, *y = 'tykl'
print(x, y)  # x=t,y=['y', 'k', 'l']
x, *y = {1, 'ysl', 'oo'}
#注意集合本身是无序的，所以x时随机匹配的，剩下的都给了y聚合打包起来
print(x, y)  # x=ysl,y=[1, 'oo']
# 异常情况
#*x = 1, 2  # 报错：SyntaxError: starred assignment target must be in a list or tuple
x=1,2
*x, = x  # x=[1, 2],此招可以让元组快速转换成列表
print(x)
# 解包
# 元祖
a = (1, 2, 3)
print(*a)  # 打印1 2 3
# 列表
b = [1, 2, 3]
print(*b)  # 打印1 2 3
# 字典
c = {'a': 1, 'b': 2}
print(*c)  # 打印 a b
print(*c.values())  # 打印 1 2
print(*c.items())  # 打印 ('a', 1) ('b', 2)
"""字典中的键本质上就在值上层，就是说优先操作它，解包字典默认解包键，当然可以指定解包键或者值，升至键值对的元组，字典感觉应该是两层的映射关系"""
# 集合
d = {1, 2, 2}
print(*d)  # 打印 1 2
# 字符串
e = '6yt1'
print(*e)  # 打印 6 y t 1

print()函数只支持 *args，不支持 **kwargs

print(**c) 
# 报错：TypeError: 'a' is an invalid keyword argument for print()

打包、解包在函数中的应用

 在函数定义时：使用 */** 收集元素进行打包，不限制传入参数的个数，分为2种：

• *args：使用元祖获取传入的参数
• ** kwargs：使用字典接收传入的 k=w 形式的关键字参数

python可变参数详解以及lambda函数-CSDN博客

def myfunc(*args, **kwargs):
    print(type(args),type(kwargs))
    print(args)
    print(kwargs)
 
myfunc(1, 2, 3, a=1, b=2)
 
执行结果：
 
(1, 2, 3)
{'a': 1, 'b': 2}

注意点：（1）python语法规定：*args参数需要放在 **kwargs参数前；（2）python语法规定：**kwargs关键字参数后不能有其他参数；（3）（参数1,*args,参数2）必须要求函数传递参数2，且参数2必须是关键字参数或者默认参数

def myfunc5(x, *args, y=1):
    print(f'x:{x}\nargs:{args}\ny:{y}')


myfunc5(7, 8, 9, 10, 11)

def myfunc5(x, *args, y):
    print(f'x:{x}\nargs:{args}\ny:{y}')
 
myfunc5(7, 8, 9, 10, 11, y='aa')
 
执行结果：
x:7
args:(8, 9, 10, 11)
y:aa

函数传参解包

def myfunc2(x, y, z):
    print(x, y, z)
 
li = [1, 2, 3]
myfunc2(*li)
 
执行结果：
1 2 3

# 根据key值匹配函数的参数值，依次将value值传入函数中
def myfunc2(a, b, c):
    print(a, b, c)
 
dic = {'c':1, 'a':2, 'b':3}
myfunc2(**dic)  # 根据字典key将对应value值传入函数中，顺序不重要，但是key不能多不能少
 
执行结果：
2 3 1

def myfunc3(x, *args, **kwargs):
    print(f'x:{x}\nargs:{args}\nkwargs:{kwargs}')
    pass
 
li = 'ysl', 99, 88
myfunc3(9, *li, a=9, **{'name':'ysl', 'age': 18})
 
执行结果：
x:9
args:('ysl', 99, 88)
kwargs:{'a': 9, 'name': 'ysl', 'age': 18}

puthon多进程多线程中的任务参数传参的时候也是有自动解包把。。