1.0.内置函数：
1.0.1.abs（）
取绝对值
print(abs(-10))
#打印结果：10
1.0.2.all（）
判断列表当中的bool值是否都为true
a = [0, 1, 2, 3, 4, 5, 6, 7]
print(all(a))
#可以看到列表其中有一个元素为0他的bool值为false，那么整体就为false
b = [ 1, 2, 3, 4, 5, 6, 7]
print(all(b))
#整体为true，则返回ture
1.0.3.any（）
只要有任意一个为true，那么就返回true
a = [0, 1, 2, 3, 4, 0, 0, 0]
print(any(a)) # 任意一个为ture，那么就返回true
1.0.4.bool（）
对bool值的判断
print(bool(0))
#0的bool值为false，所以返回值为false
print(bool(1))
#1的bool值为true，所以返回值为true
1.0.5.chr（）
输入一个整型数字，返回他的ASCII值
print(chr(97)) #返回一个a
1.0.6.dict（）
不加参数，可以为你创建一个空的字典，如果加参数可以为你创建于一个带key和value的字典
print(dict()) # 打印结果为{}
print(dict(name="iwbf", age=18)) # 打印结果为{'name': 'iwbf', 'age': 18}
1.0.7.dir（）
打印当前作用域中的所有变量名，前面_file_，有这种两个下划线加个变量名的是python自带变量
name="iwbf"
age=18
print(dir())
#打印结果：
# ['__annotations__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'age', 'name']
1.0.8.help（）
如果你不知道一个函数如何使用，可以使用help查看这个函数的使用方法。
print(help(dir))
1.0.9.id（）
可以查看变量在内存中的地址
a = [0, 1, 2, 3, 4, 0, 0, 0]
print(id(a))
# 打印结果：2101145827904
1.0.10.input（）
等待用户输入
a = input()
print(a)
1.0.11.int（）
强制将字符转换为int类型
a = '8'
print(int(a))
1.0.12.len（）
计算字符串长度
b = "dwadwa"
print(len(b)) #打印结果：6
1.0.13.list（）
生成一个空列表
print(list()) # 打印结果：[]
1.0.14.locals（）
打印当前作用域中所有变量名 和 变量值
name = "iwbf"
age = 18
print(locals())
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000002010BC748E0>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:\\pycharmProjects\\python2023特训营\\Day02\\user_login.py', '__cached__': None, 'name': 'iwbf', 'age': 18}
1.0.15.max（）
求最大值
l = list(range(10))
print(max(l)) #打印结果：9
1.0.16.min（）
求最小值
l = list(range(10))
print(min(l)) #打印结果：0
1.0.17.sum（）
求和
l = list(range(10))
print(sum(l)) #打印结果：45
1.0.18.open（）
用于打开文件的函数
1.0.19.ord（）
传一个字符，可以帮你打印出他的ASCII码值
print(ord("a"))
#打印结果：97
1.0.20.print（）
打印出输出函数
1.0.21.range（）
range是一个内置函数，range（start，stop，step=1），start表示序列起始值（默认为0），stop表示序列终止值，不包括该值，即生成的序列中最大值为stop-1，step表示序列步长（默认为1）。start、stop、step均为整数类型。
100取不到所以要写101如果不写start则默认为0，那么就会打印0-100
for i in range(101):
print(i)
# 打印结果：0-100
修改步长
for i in range(1, 101, 2):
print(i)
# 打印结果：1-100的奇数
range的反向使用，和字符串的切片操作类似
for i in range(10, 0, -1):
print(i)
# 打印结果：10-1
1.0.22.round（）
将小数取整，如果后面加参数，可以保留多少位小数
print(round(3.1415)) # 打印结果：3
print(round(3.1415, 2)) # 打印结果：3.14
1.0.23.str（）
把任何一个数据变成字符串
a = 89748
print(str(a))
a = [9, 8, 9, 61, 4, 6, 28, 6]
print(str(a)) # 打印结果：[9, 8, 9, 61, 4, 6, 28, 6]
1.0.24.type（）
打印出变量的数据类型
a = [9, 8, 9, 61, 4, 6, 28, 6]
b = str(a) # 打印结果：[9, 8, 9, 61, 4, 6, 28, 6]
print(b)
print(type(b)) # 打印结果：<class 'str'>
1.0.25.zip（）
将列表中的数据一一对应，如果超出则丢弃，不管是上面超出还是下面超出
a = ["iwbf", "op", "cf"]
b = ["girl", "man", "humu"]
for i in zip(a, b):
print(i)
# 打印结果：
# ('iwbf', 'girl')
# ('op', 'man')
# ('cf', 'humu')
1.0.26.filter（）
将列表中的每一个元素交给第一个参数（函数）运行，若结果为真，则保留这个值
l = list(range(10))
def compare(x):
if x > 5:
return x
print(l)
for i in filter(compare, l):
print(i)
1.1.int型内置函数：
1.2.float型内置函数：
1.3.str型内置函数：
1.3.1.center
bb = "iwbf" //将字符串bb放到中间，其他的用- 填充
print(bb.center(50, "-")) //-----------------------iwbf-----------------------
1.3.1.count //用于计算指定字符，出现在字符串中的次数
c = "woaini iwbf wdaii"
print(c.count("w")) //计算出为3次
print(c.count("w", 0, 4)) //如果你只需要计算到第一个到第四个字母中的w个数，那么你可以规定他的下标。结果为1
1.3.1.endswith //判断字符串是否以什么为结尾
c = "woaini iwbf wdaii"
print(c.endswith("ii")) //判断结尾是否为ii结尾，返回结果为True
1.3.1.startswith //判断字符串是否以什么为开头 //与endswith使用相同
1.3.1.find
c = "woaini iwbf wdaii"
print(c.find("fb")) //此时找的是fb很明显找不到，那么结果就会返回-1
print(c.find("iwbf")) //此时找到了，那么就会返回第一个字符的下标
1.3.1.isdigit //判断是否是数字字符串，用于判断用户是否输入的为数字字符串，是就可以直接用强制转换，将数字字符串转换为整型数字
1.3.1.join
".join() 拼接字符串使用，引号中间，表示需要拼接的间隔符，（）写需要拼接的对象
e = ["a", "b", "c"]
p = "".join(e)
print(p) //因为引号中什么都没加所以打印结果为abc
p = "~".join(e)
print(p) //添加了~所以打印结果为a~b~c
注：列表中的对象不可既有字符，又有整形，那么就无法拼接，报错。
1.3.1.replace
c = "wadwa55"
print(c.replace("w", "m")) //前面一个为老的参数，后面为需要替换的新参数，默认为全部替换，结果为madma55
print(c.replace("w", "m", 1)) //如果写了替换多少个，那么就只会从左开始数替换第一个，结果为madwa55
1.3.1.split
c = "awop adwa 5w5"
print(c.split()) //将字符串变成一个列表，默认为以空格为分隔
打印结果：['awop', 'adwa', '5w5']
print(c.split("w")) //修改默认，然后改为以w为分隔
打印结果：['a', 'op ad', 'a 5', '5']
print(c.split("w", 1)) //修改分隔次数，改成只分一次
打印结果：['a', 'op adwa 5w5']
1.3.1.strip
c = " wadwa55 " //使用strip可以用来消除字符串的空格，无法消除字符串内部的空格，只能消除字符串两边的空格
print(c.strip()) //打印结果wadwa55
1.4.list型内置函数：
1.4.1.insert
list = [1, 2, 3]
list.insert(-1, 4)
list.insert(10, 5) //只要正负索引都没有越界，那么就会正常插入在索引元素的前面。
list.insert(-20, 0) //当索引越界时如果是正索引越界，那么就会插入到元素的最后一位；如果是负索引越界时，那么会插入到列表的第一个
print(list) //[0, 1, 2, 4, 3, 5]
1.4.2.append
追加：添加到列表的尾部
list = [1, 2, 3]
print(list) // [1, 2, 3]
list.append("wdawod")
print(list) //[1, 2, 3, 'wdawod']
list.append(99)
print(list) //[1, 2, 3, 'wdawod', 99]
1.4.3.del
删除列表中的元素，不仅可以删除列表的元素，也可以删除变量字符串，等等所有东西
del后面需要写元素的下标
list = [1, 2, 3]
del list[1] //del删除列表对应下标的元素
print(list) //[1, 3]
1.4.4.remove
删掉列表中，从左到右的第一个与之匹配的元素，仅仅删一个
remove后面写元素
list = [1, 2, 3, 1]
list.remove(1) //仅删除了左边第一个
print(list) //[2, 3, 1]
1.4.5.in
list = ['win', 'rain', 'rian', 'iwbf']
print('win' in list) //True，判断win是否在列表list中，如果在返回true，如果不在返回false
print('wi' in list) //False，不是整个元素匹配则返回false
1.4.6.not in
如果不在返回true，在则返回false
只可以用来测试字符串、列表、元组、字典、集合，不可以用来测试数字类型
1.4.7.extend
c = ["aw", "op", "cf", "dnf"]
b = ["iwbf", "ttx"]
b.extend(c) //将c合并到b中，与字符串不同，字符串需要重新赋值，而列表不需要，如果你将b=b.extend(c)，那么打印出来结果为none
a=b.extend(c)
print(b) //打印结果：['iwbf', 'ttx', 'aw', 'op', 'cf', 'dnf']
print(a) //打印结果：None
1.4.8.列表嵌套
c = ["aw", "op", "cf", "dnf"]
c.insert(2, ["iwbf", "ootd"]) //在cf前面插入一个列表
print(c) //打印结果：['aw', 'op', ['iwbf', 'ootd'], 'cf', 'dnf']
print(c[2]) //打印c列表中下标为2的元素，这是一个列表，打印结果：['iwbf', 'ootd']
print(c[2][1]) //那么如果你想要取到内部列表的一个元素，那么就在下标后面多加一个，他所在内置列表的下标。打印结果：ootd。类似二维数组
1.4.9.del
c = ["aw", "op", "cf", "dnf"]
del c[1]
print(c) //del为解释器自带的删除函数，打印结果：['aw', 'cf', 'dnf']
1.4.10.pop
c = ["aw", "op", "cf", "dnf"]
b = c.pop() //pop（）参数不写时，默认删除最后一个元素，并且返回他的值，如果你需要可以将他赋值给一个变量
print(b) //打印结果：dnf
print(c) //打印结果：['aw', 'op', 'cf']
c.pop(-2) //pop也可以指定删除一个数，在（）内写下他的下标就可以了
print(c) //打印结果：['aw', 'cf']
1.4.11.remove
c = ["aw", "op", "cf", "dnf", "aw"]
c.remove("aw") //remove（）内必须写元素才可以移除，当有两个相同的元素时，只能从左到右匹配第一个与之相同的，并且删除，另外一个不会删除。
print(c) //打印结果：['op', 'cf', 'dnf', 'aw']
1.4.12.clear
c = ["aw", "op", "cf", "dnf", "aw"]
c.clear() //将列表全部清空
print(c) //打印结果：[]
1.4.13.修改操作
c = ["aw", "op", "cf", "dnf", "aw"]
c[0] = "sos"
c[-1] = "www" //直接选择列表中元素的下标，然后将新值赋值进去即可
print(c) //打印结果：['sos', 'op', 'cf', 'dnf', 'www']
1.4.14.查找操作
c = ["lkwg", "aw", "op", "cf", "dnf", "aw"]
p = "aw" in c //先判断这个值是否存在在列表c中
print(p) //打印结果：True
b = c.index("aw") //找到这个元素的下标，index会返回从左到右匹配到的第一个的索引
print(b) //打印结果：1
d = c.count("aw") //计算aw元素的个数
print(d) //打印结果：2
1.4.15.列表的切片功能
c = ["lkwg", "aw", "op", "cf", "dnf", "aw"]
print(c[4:5]) //顾头不顾尾，下标为4的能取到，而后面的只能取到下标为5的前一位，默认是从左往右切，除非修改他的步长
打印结果：['dnf']
print(c[4:]) //如果右边为空不写，那么代表取到最后一位
打印结果：['dnf', 'aw']
print(c[4:6]) //python3.0的新特性，右边下标越界，也代表取到最后一位
打印结果：['dnf', 'aw']
print(c[0:-1]) //可以取负值，但是也是顾头不顾尾
打印结果：['lkwg', 'aw', 'op', 'cf', 'dnf']
print(c[-1:0:-1]) //修改步长为-1，代表从右往左取，也可以跳着取将步长修改为2
打印结果：['aw', 'dnf', 'cf', 'op', 'aw']
1.4.16.正排序
c = ["lkwg", "aw", "op", "cf", "dnf", "bw"]
c.sort() //按照ascii码，字符串首字符从小到大排序
print(c) //打印结果：['aw', 'bw', 'cf', 'dnf', 'lkwg', 'op']
1.4.17.反转
c = ['5', '6', '8', '3', '9', '10', '1', '2']
c.reverse() //将列表反转
print(c) //打印结果['2', '1', '10', '9', '3', '8', '6', '5']
1.4.18.循环列表
c = ['5', '6', '8', '3', '9', '10', '1', '2']
for i in c: //循环将列表中的值赋值给i
print(i) //将i的值打印出来
for i in enumerate(c): //枚举函数一个内置函数，循环将列表中的下标加元素值赋值给i。
print(i) //打印下标和元素值
打印结果：
(0, '5')
(1, '6')
(2, '8')
(3, '3')
(4, '9')
(5, '10')
(6, '1')
(7, '2')
1.5.元组型内置函数：
1.6.字典型内置函数：
{key1：value1，key2：value2}
st = {
"iwbf":[18,"shuaige",100000], //左边为key，右边为值
"wad":[90,"dwad",1000],
"alb":[30,"awd",851500],
}
特性：
1.key必须为不可变数据类型（字符串、数字）、必须唯一
st = {
['dwaw']:[18,"shuaige",100000], //当我存放一个列表作为key时就会报错
"wad":[90,"dwad",1000],
"alb":[30,"awd",851500],
}
st = {
"iwbf":[18,"shuaige",100000],
"iwbf":[20,"shuaige",555], //当我存放了两个iwbf时，不会报错，但是会覆盖上面的iwbf值
}
print(st["iwbf"]) //所以我打印的结果为：[20, 'shuaige', 555]，所以必须唯一
2.可存放任意多个value、可修改、可以不唯一
3.key无序
4.查询速度快，且不受dict的大小影响
字典的操作：
1.6.1.增加操作
st = {
"iwbf": [18, "shuaige", 100000],
"op": [20, "shuaige", 555],
}
st['cf'] = [56, 5000] //在原字典中添加一个新的key和value值，注：如果你此时添加的key和原来的字典当中的key值相同时，那么你不会创建一个新的key，当你此时新的key和老的key的value值不同时，那么会修改老的key中的value值，而不是创建一个新的key。
print(st['cf'])
1.6.2.删除操作
st = {
"iwbf": [18, "shuaige", 100000],
"op": [20, "shuaige", 555],
"cf": [20, "shuaige", 555],
}
st.pop("iwbf") //删除指定key：iwbf
del st["op"] //删除指定key：op
st.clear() //清空字典
print(st) //打印结果为{}空
1.6.3.查找操作
st = {
"iwbf": [18, "shuaige", 100000],
"op": [20, "shuaige", 555],
"cf": [20, "shuaige", 555],
}
A = st["iwbf"] //直接查找key对应的值，若存在则返回key所对应的值，若不存在则会报错。
print(A) //打印结果：[18, 'shuaige', 100000]
B = st.get('DNF') //接查找key对应的值，若存在则返回key所对应的值，若不存在则会返回一个default值（default默认为None）。
print(B) //打印结果：None
C = 'IWBF' in st //判断key值是否存在，存在则返回true，没有则返回false
print(C) //打印结果：False
D = st.keys() //返回字典中所有的key的列表
print(D) //打印结果：dict_keys(['iwbf', 'op', 'cf'])
E = st.values() //返回字典中所有的value的列表
print(E) //打印结果：dict_values([[18, 'shuaige', 100000], [20, 'shuaige', 555], [20, 'shuaige', 555]])
F = st.items() //返回字典中所有的（key和vlaue）元组的列表
print(F) //打印结果：dict_items([('iwbf', [18, 'shuaige', 100000]), ('op', [20, 'shuaige', 555]), ('cf', [20, 'shuaige', 555])])
1.6.4.循环打印
三种方法
1.for i in st.keys(): //打印字典中的key
print(i)
打印结果：
iwbf
op
cf
2.for i, j in st.items(): //将字典当中的key和value循环赋值给i，j然后打印
print(i, j)
打印结果：
iwbf [18, 'shuaige', 100000]
op [20, 'shuaige', 555]
cf [20, 'shuaige', 555]
3.for i in st: //效率速度最快，直接将字典中的值赋值给i，但是打印的时候注意要打印i和st【i】。如果只打印i，那么只会打印key
print(i, st[i])
打印结果：
iwbf [18, 'shuaige', 100000]
op [20, 'shuaige', 555]
cf [20, 'shuaige', 555]
print(len(st)) //len（）方法可以同时用于列表、字符串
1.7.集合型内置函数：
2.1.random模块：
使用模块时，需要导入模块包，否则无法使用
例：import random，import string，import sys
2.1.1.random.choice（） //参数可以是字符串，也可也是一个列表
s = "abcdefghijklmn"
print(s)
a = random.choice(s)
print(a) //参数为一个字符串，可以在字符串中随机取出一个字符
c = [464, 48, 6, 21, 584, 214, 3123]
print(c)
b = random.choice(c)
print(b) //参数为一个列表，那么此时就是随机取出一个列表的元素
2.1.2.random.sample（） //从数据源中随机取出自定义个值
c = list(range(1, 21)) //组建一个列表，从1到20
print(c) //[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
b = random.sample(c, 3) //从列表c当中随机取三个元素
print(b)
2.1.3.random.randint（） //从你需要的整型范围中随机选取一个随机数
print(random.randint(1, 101)) //从1-100中随机选取一个随机数
2.2.string模块：
2.2.1.strin.ascii_letters //小写字母到大写字母的全部字符
s = string.ascii_letters
print(s)
2.2.2.strin.ascii_uppercase //大写字母
s = string.ascii_uppercase
print(s)
2.2.3.strin.ascii_lowercase //小写字母
s = string.ascii_lowercase
print(s)
2.2.4.strin.punctuation //打印特殊符号
s = string.punctuation
print(s)
2.2.5.strin.digits //打印0-9数字
s = string.digits
print(s)
2.3.sys模块：
2.3.1.sys.argv
可以获取命令行参数（argv 属性表示传递给Python脚本的命令行参数列表）
sys.argv:以列表的方式获取运行Python程序的命令行参数存放其中，其中sys.argv[0]通常就是指该Python程序脚本名称，sys.argv[1]代表第一个参数，sys.argv[2]代表第二个参数，第三、第四参数以此类推
753
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
