1、枚举——enumerate
#NO.1正常操作
a=['h','b','c','d']
for i,j in enumerate(a):
print(i,j)
输出结果：
0 h
1 b
2 c
3 d
==================================================
#NO.2带参数的enumerate
print(list(enumerate('abc',1)))
输出结果：[(1, 'a'), (2, 'b'), (3, 'c')]
2、字典生成
1)推导式生成字典
my_dict={i: i*i for i in range(4)}
print(my_dict)
输出结果：{0: 0, 1: 1, 2: 4, 3: 9}
2)dict.fromkeys的应用
NO.1列表去重
value_list = ['597', '597', '598', '598', '599', '599', '600', '600', '601', '601']
print(list(dict.fromkeys(value_list)))
result==>['597', '598', '599', '600', '601']
NO.2获取字典的key值，返回列表
get_orgid = {'user1_0': '597', 'user1_1': '597', 'user2_0': '598', 'user2_1': '598', 'user3_0': '599', 'user3_1': '599',
'user4_0': '600', 'user4_1': '600', 'user5_0': '601', 'user5_1': '601'}
print(list(dict.fromkeys(get_orgid)))
result==>['user1_0', 'user1_1', 'user2_0', 'user2_1', 'user3_0', 'user3_1', 'user4_0', 'user4_1', 'user5_0', 'user5_1']
NO.3生成字典
seq = ('name','age','job')
v1 = dict.fromkeys(seq,'hello')
v2 = dict.fromkeys(range(5),'python')
print(v1) ==>{'name': 'hello', 'age': 'hello', 'job': 'hello'}
print(v2) ==>{0: 'python', 1: 'python', 2: 'python', 3: 'python', 4: 'python'}
2)字典合并和元素添加
NO.1
date_info = {'year': "2020", 'month': "01", 'day': "01"}
track_info = {'artist': "Beethoven", 'title': 'Symphony No 5'}
all_info = {**date_info, **track_info}
print(all_info) ==>{'year': '2020', 'month': '01', 'day': '01', 'artist': 'Beethoven', 'title': 'Symphony No 5'}
NO.2
date_info = {'year': '2020', 'month': '01', 'day': '7'}
event_info = {**date_info, 'group': "Python Meetup"}
print(event_info) ==>{'year': '2020', 'month': '01', 'day': '7', 'group': 'Python Meetup'}
3、eval是把字符串转换成列表，字典和元组
语法格式：eval(source,globals,locals)
source ： 字符串
globals ： 变量作用域，全局命名空间，如果被提供，则必须是一个字典对象。
locals ： 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
#NO.1正常使用
ex="[1,2,3]"
mylist=eval(ex)
print(mylist) ==>[1, 2, 3]
#NO2.globals&locals
print(eval("{'name':'kitty','age':age}",{'age':22})) ==>{'name': 'kitty', 'age': 22}
age=19
print(eval("{'name':'kitty','age':age}",{'age':22},locals())) ==>{'name': 'kitty', 'age': 19}
※调用的依然是locals的19
#NO.3
x = 100
y = 200
def compute():
x = 10
y = 20
print(eval("x + y", globals())) #调用全局变量
print(eval("x + y", locals())) #调用局部变量
compute()
输出结果：
300
30
4、浏览了其他人的学习笔记，发现一种很好的命名编写规范
def test(_argv):
就是把所有的参数前面都加上_下划线，这样你在函数体中，一眼就可以看出那些是局部变量，那些是作为参数传入的，类似把全局变量前面加上g
5、pow函数
pow(x,y):这个是表示x的y次幂
pow(x,y,z)：这个是表示x的y次幂后除以z的余数
print(pow(2,3)) ==>8
print(pow(2,3,3)) ==>2
6、operator排序——只针对int和str
import operator
NO.1
list=['hello','ifrld','lily']
#0代表元素里的第一位比较，1代表第二位，依次类推
list.sort(key=operator.itemgetter(0))
print(list) ==>['hello', 'ifrld', 'lily']
list.sort(key=operator.itemgetter(2)) #对比的是：l l r
print(list) ==>['hello', 'lily', 'ifrld']
NO.2
※如果要对元素是字符串的，进行字符串的其它字母排序，还可以如此操作：
a=['hello','worl','if']
res=sorted(a,key=len) #按照长度标准排序
print(res) ==>['if', 'worl', 'hello']
※还可以转换成小写字母，按照ASCII码排序：key=str.lower
NO.3如果对象是个多层嵌套
f = [{'name':'abc','age':20},{'name':'def','age':30},{'name':'ghi','age':25}]
def age(s):
return s['age']
ff = sorted(f,key = age) ==>[{'age': 20, 'name': 'abc'}, {'age': 25, 'name': 'ghi'}, {'age': 30, 'name': 'def'}]
相当于：
result = sorted(f,key = lambda x:x['age'])
7、f-string
1）亦称为格式化字符串常量（formatted string literals），是Python3.6新引入的一种字符串格式化方法。
NO.1
name='Eric'
print(f'my name is {name} ') ==>my name is Eric
one_dict = {"name": "江辰", "age": 18, "hobby": ["running", "singing"]}
print(f"姓名：{one_dict['name']},爱好：{one_dict['hobby']}") ==>姓名：江辰,爱好：['running', 'singing']
NO.2还可以和lambda一起用
res=f'result is {(lambda x:x**2+1)(2)}'
print(res) ==>result is 5
NO.3可以与函数一起用
def mult_two_num(a):
print("计算两数之和")
print(10+a)
f"{mult_two_num(9)}" ==>19
2）获取函数名称
NO.1函数外获取方法名
def fuc_name():
print('hello girl')
res =fuc_name.__name__
print(res) ==>fuc_name
NO.2函数内获取方法名
import sys
def fuc_name():
print("当前函数名称是:%s"%sys._getframe().f_code.co_name)
fuc_name() ==>当前函数名称是:fuc_name
NO.2获取类名
import sys
class fuc_name():
def test(self):
print("获取当前的类名称：%s"%self.__class__.__name__)
print("获取当前的方法名称：%s"%sys._getframe().f_code.co_name)
fuc_name().test()
运行结果：
获取当前的类名称：fuc_name
获取当前的方法名称：test
8、多字符拆分
import re
list='2019-08-06 12:03:07'
pattern=r'[-|:| ]'
result=re.split(pattern,list)
print(result)
运行结果：['2019', '08', '06', '12', '03', '07']
9、join函数
- 语法：‘seq’.join(seq)
参数说明
sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串
返回值：返回一个以分隔符sep连接各个元素后生成的字符串
list = ['hello','world','lily']
print(''.join(list))
>>helloworldlily
list = ['hello','world','lily']
print(':'.join(list))
>>hello:world:lily
注：还有路径拼接：os.path.join(path1[,path2[,......]])
10、itertools.permutations()返回可迭代对象的所有数学全排列方式
import itertools
def permutation(li):
print(list(itertools.permutations(li)))
permutation(['ab','cd','ef'])
输出：=>[('ab', 'cd', 'ef'), ('ab', 'ef', 'cd'), ('cd', 'ab', 'ef'), ('cd', 'ef', 'ab'), ('ef', 'ab', 'cd'), ('ef', 'cd', 'ab')]
11、访问私有静态属性和私有方法
class Person():
head = 'lily' //静态属性
__body = 'me' //私有静态属性
def __init__(self,name,age):
self.name = name
self.age = age
def eat(self):
print('hahah')
def __drink(self): //私有方法
print('siyou')
a= Person('小猫咪',2)
print(a.head)
print(Person.__dict__) //所有类下的属性方法都在此
a._Person__drink()
=>>结果：
lily
{'__module__': '__main__', 'head': 'lily', '_Person__body': 'me', '__init__':
<function Person.__init__ at 0x00000187F62AE048>, 'eat':
<function Person.eat at 0x00000187E7594620>, '_Person__drink':
<function Person.__drink at 0x00000187F64ADC80>, '__dict__':
<attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute
'__weakref__' of 'Person' objects>, '__doc__': None}
siyou
12、递归函数：所有返回自身方法的都是递归函数
一个数的阶乘：
def factorial(n):
return fact_iter(n, 1)
def fact_iter(n, product):
if n == 1:
return product
return fact_iter(n - 1, n * product)
print(factorial(5)) ==>120
13、删除字符串中的指定字符串
.strip()函数，删除字符串中的首个‘ab’
a = 'abcdabefdglliiggabbbnnvvmm'
b = a.strip('ab')
print(a) ==> cdabefdglliiggabbbnnvvmm
.replace(old, new[, count]) 函数，可以指定删除多少个指定字符串
a = 'abcdabefdglliiggabbbnnvvmm'
c = a.replace('ab', '')
print(c) ==> cdefdglliiggbbnnvvmm
正则表达式：sub(pattern, repl, string, count=0, flags=0) 函数
import re
a = 'abcdabefdglliiggabbbnnvvmm'
d = re.sub('ab', '', a)
print(d) ==> cdefdglliiggbbnnvvmm
14、python下载图片和视频方法
安装相应的包：pip install you-get
cmd打开终端输入：you-get -o D:/xxx www.xxx.xxx.com
15、python比较日期的方法
1）两个日期的比较
import datetime
a = datetime.date.today()
b = datetime.date(2017,2,1)
print(f'等于:{a.__eq__(b)}')
print(f'大于等于:{a.__ge__(b)}')
print(f'大于:{a.__gt__(b)}')
print(f'小于等于:{a.__le__(b)}')
print(f'小于:{a.__lt__(b)}')
print(f'不等于:{a.__ne__(b)}')
2）获得两个日期的间隔
print(f'时间相差：{a.__sub__(b)}') ==> a-b 时间相差：1480 days, 0:00:00
16、列表切片截取
1）列表复制
old = ['a','b','c','d','e','g','f','h','i','j']
new = old[:]
print(id(old)) ==>2014972047304
print(id(new)) ==>2014972055624
2）列表切片：list[start:end:step]，※其中end也可以理解截取多少长度
old = ['a','b','c','d','e','g','f','h','i','j']
print(old[0:5]) ==>['a', 'b', 'c', 'd', 'e']，从索引0开始，截取长度为5
print(old[0:5:2]) ==>['a', 'c', 'e']，从索引0开始，截取长度为5，步长为2
3）※将嵌套列表平均拆分n份
get_user = [['597', '2412372', '1605903'], ['597', '2412375', '1605906'], ['597', '2412376',
'1605907'], ['597', '2412377', '1605706'], ['598', '2412378', '1605909'], ['598', '2412381',
'1605912'], ['598', '2412382', '1605913'], ['598', '2412383', '1605914'], ['599', '2412384',
'1605915'], ['599', '2412387', '1605918'], ['599', '2412388', '1605919'], ['599', '2412389',
'1605922'], ['600', '2412390', '1605921'], ['600', '2412393', '1605924'], ['600', '2412394',
'1605925'], ['600', '2412395', '1605926'], ['601', '2412396', '1605927'], ['601', '2412399',
'1605930'], ['601', '2412390', '1605936'], ['601', '2412391', '1605935']]
for i in range(0,len(get_user),5): # 此时的步长5，将理解为平分后每个嵌套列表里的个数
#print(i)
print(get_user[i:i + 5])
17、random的使用
1）random.sample(population, k):随机截取k个值
import random
import string
# string.digits的作用是生成数组，包括0-9
num = string.digits
person = "".join(random.sample(num, 6))
print(person) ==>返回的是列表
2）random.choice(seq):从非空序列中随机选取一个数据并带回，可以是list，tuple等
import random
res = ['name','jog','work','python','favourite','love']
print(random.choice(res)) ==>随机显示列表res里的值
3）random.choices(population,weights=None,*,cum_weights=None,k=1):weights可以设置权重，代表列表中第几个元素出现的概率
import random
res = ['name','jog','work','python','favourite','love']
print(random.choices(res,k=6,weights=[1,0,0,0,0,0])) ==>代表第一个元素那么出现的概率是1/（1+0+0+0+0），所以只有name出现
※注意：这里的k和weights长度，是跟res长度对应的，不能少也不能多
※小结：random.choices()和random.sample()里的k的区别在于：choices是选取k次，取完之后又放回去重新取，就会取到重复的；而sample是取k个，不会重复且不能超过集群的元素个数~！
17、打印函数注释
def test():
"""呵呵哒"""
print(test.__doc__)
test()
==> 呵呵哒
18、字符相关函数
1）首字母大写：capitalize
var = 'iloveyou'
print(var.capitalize())
==>Iloveyou
2）字符串中的每个单词首字母大写：title，但是字母间要空格
res = 'i love you'
print(res.title())
==>I Love You
3）将字符串里的大写变小写，小写变大写：swapcase
strs = 'i 我 LOVE 爱 You 你'
print(strs.swapcase())
==>I 我 love 爱 yOU 你
4）建测字符是否以某个字符开头：startwith
var = 'iloveyou.sh'
print(var.startswith('i')) ==>True
print(var.endswith('.sh')) ==>True
19、析构方法
析构方法是在对象实例被销毁时，触发，同__init__一样是自动执行作用：关闭资源注意：是对象被销毁时触发，而不是这个方法销毁了对象
对象会在哪些情况下被销毁？
当程序执行完毕，内存中所有的资源都会被销毁释放使用del删除时实例对象不再被调用时，会自动销毁
class Test:
def __init__(self):
print('我是初始化方法')
def write(self):
print(f'方法名字是{self.write.__name__}')
def __del__(self):
print('析构方法被触发了')
res = Test()
res.write()
==>
========我是初始化方法========
方法名字是:write
========析构方法被触发了========
