python -data_python data函数

1.ceil(x):返回数字的向上整数。如math.ceil(4.1) 返回 5。

floor(x):返回数字的下舍整数。如math.floor(4.9)返回 4

gcd(x,y):返回x和y的最大公约数。如math.gcd(3,6) 返回3

divmod(x,y):返回x除以y的商和余数。 如divmod(10,3) 返回(3, 1)。

factorial(x):返回x阶乘的值 如math.factorial(3) 返回 6。

prod(x):返回迭代器x里每个元素之积。如prod(2,3,4) 返回 24。

2.随机函数

 random()：在[0,1)范围内随机生成一个浮点数。如random.random()。

 uniform(x,y)：[x,y]范围内随机生成一个浮点数。如random.uniform(3,5)。

randint(x,y)：在指定范围内随机一个整数。如random.randint(1,10)。

randrange([start,] stop [,step])：指定范围内按指定基数递增集合中获取一个随机数，默认值为 1。

start -- 指定范围内的开始值，包含在范围内。

stop -- 指定范围内的结束值，不包含在范围内。

step -- 指定递增基数。

如random.randrange(1, 100, 2)从 1-100 中选取一个奇数。

choice(x)：从序列x中随机挑选一个元素，x --可以是一个列表、元组、字符串。

如random.choice(range(10))，从0到9中随机挑选一个整数。

sample(x,y)：从序列中随机指定个数的元素。如x = [1,2,3,4,5]，random.sample(x,3)。

 seed([x])：改变随机数生成器种子，需在调用其他随机函数前调用此函数。

如random.seed(8)，提前指定种子数字为8。

 shuffle(x)：将序列x的所有元素随机排序。如random.shuffle(x)。

3.字符函数:

split(): split(str="", num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，

则仅截取 num+1 个子字符串。x = 'h,e,l,l,o'，x.split(',')返回['h', 'e', 'l', 'l', 'o']。

rsplit():rsplit(str="", num=string.count(str))以 str 为分隔符从右边截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串。

x = 'h,e,l,l,o'，x.rsplit(',',2)返回['h, e, l', 'l', 'o']。

rpartition():指定字符串最后一次出现，并将该字符串拆分为包含三个元素的元组。

x = 'hello'，x.rpartition('l')，返回('hel', 'l', 'o')

find(x):find(str, beg=0, end=len(string))检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，

则检查是否包含指定范围内，如果包含返回开始索引值，否则返回-1。

x = 'hello world' x.find('l')返回2；x.find('l',5)返回9
 

rfind():rfind(str, beg=0,end=len(string))​类似于 find()函数，不过是从右边开始查找。

x = 'hello'，x.rfind('l')，返回3，x.rfind('l',0,3)返回2

index(x):index(str, beg=0, end=len(string))跟find()方法一样，只不过如果str不在字符串中会报一个异常。x = 'hello world' x.index('l')返回2； x.index('l',5)返回9

rindex():rindex( str, beg=0, end=len(string))类似于 index()，不过是从右边开始。

x = 'hello'，x.rindex('l')，返回3，x.rindex('l',0,3)返回2。

center(x,y):返回一个指定的宽度 x 居中的字符串，y 为填充的字符，默认为空格。

x = '漫步桔田' x.center(10,'*') ，返回 ***漫步桔田***。

ljust():ljust(width[, fillchar])返回一个原字符串左对齐,并使用 fillchar,填充至长度 width 的新字符串，fillchar 默认为空格。x = 'hello'，x.ljust(8,'*')，返回hello***。

rjust():rjust(width,[, fillchar])返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串。x = 'hello'，x.rjust(8,'*')，返回***hello

count(x):count(x, beg= 0,end=len(string))返回 x在字符出现次数， beg和end 用于返回指定范围内 x 出现次数。x = 'Hello'  x.count('l') 返回 2；x.count('l',3)返回 1 。

replace():replace(old, new [, max])将字符串中 old 替换成 new,如果 max 指定，则替换不超过 max 次。x = 'aacc'，x.replace('c','b')，返回aabb，x.replace('c','b',1)，返回aabc。

join(x):join(x)以指定字符作为分隔符，将 x 中所有元素合并为一个新字符串。

x = 'hello' '*'.join(x) ，返回h*e*l*l*o。

zfill():返回长度为 width 的字符串，原字符串右对齐，前面填充0。x = 'hello'，x.zfill(10)，返回00000hello

lstrip():截掉字符串左边的空格或指定字符。x = '   HELLO'，x.lstrip()，返回HELLO。

rstrip():删除字符串末尾的空格或指定字符。x = 'hello***'，x.rstrip('*')，返回hello。

strip():在字符串上执行 lstrip()和 rstrip()。x = '**hello**'，x.strip('*')，返回hello。

splitlines(x):按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，

如果参数 x 为 False，不包含换行符，如果为 True，则保留换行符。

'12\r34\r\n56\n78'.splitlines()，返回['12', '34', '56', '78']。
'12\r34\r\n56\n78'.splitlines(True)，返回['12\r', '34\r\n', '56\n', '78']。

expandtabs():

expandtabs(tabsize=8):expandtabs() 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16...等处给出制表符位置，如制表符位置字符数不足 8 倍数则以空格代替。x = 'hello\tworld' x.expandtabs() 返回hello   world补充3个空格。
 

startswith():startswith(x, beg=0,end=len(string))检查字符串是否是以指定子字符串 x 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。

x = 'hello'，x.startswith('h')，返回True。

endswith():

endswith(x, beg=0, end=len(string))检查字符串是否以 x 结尾，如果 beg 和 end 指定则检查指定范围内是否以 suffix 结束，如果是，返回 True,否则返回 False。

x = 'hello' x.endswith('o')返回True；x.endswith('l',0,3)返回True。

isalnum():如果字符串不为空并且所有字符都是字母或数字，则返回 True，否则返回 False。

x = 'hello world' x.isalnum()返回False。

isalpha():如果字符串不为空且所有字符都是字母或中文字，则返回 True, 否则返回 False。

x = 'hello漫步' x.isalpha()返回 True

isdigit():如果字符串只包含数字则返回 True 否则返回 False。x = '123456' x.isdigit()，返回 True

isnumeric():如果字符串中只包含数字字符，则返回 True，否则返回 False。x = '123456' x.isnumeric() 返回 True。

isdecimal():检查字符串是否只包含十进制字符，如果是返回 True，否则返回 false。

x = '123'，x.isdecimal()，返回True。

isspace():如果字符串中只包含空格，则返回 True，否则返回 False。x = ' ' x.isspace()，返回 True。

字符格式%

%c  格式化字符及其ASCII码。   '我是字母 %c 。' % (97) ，返回我是字母 a 。

%u  格式化无符号整型。  '我的年龄 %u。' % (21)，返回我的年龄 21 。

%i  格式化无符号十进制数。 '我的年龄 %i。' % (21)，返回我的年龄 21 

%g%G:自动将整数、浮点数转换浮点或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e）。'我的体重 %.2g。' % (1.001260e+02)，返回我的体重 100.126

%[(name)][flags][width].[precision] typecode

 (name)：参数名称，用来传入字典值的，（传入参数必须是字典）；

  flags：作为用户对一些格式的选择，只有固定的几个值，以下

                     + 右对齐：正数前加正好，负数前加负号；

                     -  左对齐：正数前无符号，负数前加负号；

                     ' ' 右对齐：正数前加空格，负数前加负号；

                     0 右对齐：正数前无符号，负数前加负号；用0填充空白处

width：表示显示宽度，如果设置宽度低于实际字符宽度时，会按照实际的宽度来输出

              如果设置宽度高于字符宽度时，会按照设置的宽度输出，空白符自动补位，右对齐。

              precision：表示小数点后精度

              typecod：用于指定输出类型（%s、%d、%f）。
 

字符格式format

列表函数

元组函数

元组是不可变数据类型，不可以进行“增删改”操作，但可通过拼接、切片完成“增删改”操作

字典函数

字典操作：

字典创建 ： x = dict(name = '漫步',age =21)  print(x)   结果: {'name': '漫步桔田', 'age': 21}

nama = ['漫漫','桔桔']   age = [23,21]   x = dict(zip(name,age))

print(x)   结果: {'漫漫: 23, '桔桔': 21}

#字典增加

x = {'name': '漫步桔田', 'age': 21}  x['scores'] = 100    print(x)

字典：{'name': '漫步桔田', 'age': 21，’scores': 100}

#字典删除

x =  {'name': '漫步桔田', 'age': 21}  del x['age']   print(x) 

结果：{'name': '漫步桔田'}

#字典修改

x =  {'name': '漫步桔田', 'age': 21}  x['age'] = 25  print(x)   

结果： {'name': '漫步桔田', 'age': 25}

#字典查询

x =  {'name': '漫步桔田', 'age': 21}  print(x['age'])   结果：21

#字典嵌套

x = {}   x['name'] = [1,2,3]   print(x)   结果：{'name':[1,2,3]}

print(x['name'][1])     结果：2 

#字典判断

x = { '漫漫':23, '桔桔': 21}  print('漫漫' in x)   结果：True    判断字典键轴是否包含'漫漫'

print('小漫' in x)   结果：False    判断字典键轴是否包含'小漫'

三、集合

无序不重复  {}或者set()函数创建，例如：{1,2,3}

set()  

将序列转换为集合。

x = [1,2,3]，set(x)，返回 {1, 2, 3} 。
y = (4,5,6)，set(y)，返回 {4, 5, 6} 。

len()  计算集合中元素个数。x = {1,2,3}，len(x))，返回 3 

max()返回集合中最大值。 x = {1,2,3}，max(x)，返回 3 。y = {'a','b','c'}，max(x)，返回 c 

add() 为集合添加新元素。  x = {1,2,3,4,5} x.add(6) 返回 x = {1,2,3,4,5,6}。

union() 返回两个集合的并集。 x = {1,3,5} y = {5,7}  x.union(y)，返回 {1, 3, 5, 7}

intersection() 返回集合的交集。  x = {1,3,5} y = {2,3,4}  z = x.intersection(y)，返回 z =  {3}。

update()将集合 y 中元素过滤掉相同元素后添加到集合 x 中 x = {1,3,5} y = {5,7}   x.update(y)，返回 x =  {1, 3, 5, 7}。

clear()移除集合中的所有元素。x = {1,2,3,4,5}  x.clear()，返回 x = set()

copy()拷贝一个集合。 x = {1,2,3,4,5} y = x.copy()，返回y = {1,2,3,4,5}

pop()随机移除元素  x = {1,2,3,4,5}  x.pop()，返回 x = {2, 3, 4, 5}

remove()移除指定元素 x = {1,2,3,4,5} x.remove(4)，返回 x = {1, 2, 3, 5}。

discard()删除集合中指定的元素。x = {1,3,5} y = {2,3,4} x.discard(3)，返回 x = {1, 5}

difference_update() 删除x集合中与y集合中相同的元素。 x = {1,3,5} y = {2,3,4} 

x.difference_update(y)，返回x = {1, 5}

intersection_update() 删除集合 x 中与指定集合 y 中不同元素。 x = {1,3,5} y = {2,3,4}

x.intersection_update(y)，返回 x = {3}

difference()返回仅存在于集合 x 中而不存在于集合 y 中的元素 x = {1,2,3} y = {2,3,4}

z = x.difference(y)，返回 z = 1

symmetric_difference()返回两个集合中不重复的元素集合。x = {1,3,5} y = {3,5,7}z = x.symmetric_difference(y)，返回 z  = {1, 7}。

symmetric_difference_update()

移除集合x、集合y中的相同元素，并将集合y中不同元素插入到集合x中。

x = {3,5} y = {5,7} x.symmetric_difference_update(y)，返回 x = {3, 7}。

isdisjoint()判断集合x、y 是否包含相同的元素，是返回 True，否则返回 False

x = {1,3,5} y = {2,3,4}  x.isdisjoint(y)，返回 False

issubset()判断指定集合 x 是否为集合 y 的子集，是返回 True，否则返回 False

x = {1,3,5} y = {1,3,5,7,9} x.issubset(y)，返回 True

issuperset()判断集合 y 是否包含指定集合 x， 是返回 True，否则返回 False。

x = {1,3,5} y = {1,3,5,7,9}，y.issuperset(x)，返回 True。

集合操作：

1. x = {1,2,3}  print(2 in x) # True 判断元素 2 是否在集合 x 中

2. x = [1,1,2,3,5,5]  print(list(set(x))) # [1, 2, 3, 5] 列表、元组去重

3. x = {1,3,5}  y = {2,3,4}  print(x-y) # {1, 5}  #差集：返回一个新集合，包括集合 x 中与集合y不同元素。

4. print(x|y) # {1, 2, 3, 4, 5} #并集：返回一个新集合，包括集合 x 和集合 y 中所有元素

5. print(x&y) # {3} #交集：返回一个新集合，仅包括集合 x 和 y 中相同的元素。

6. print(x^y) # {1, 2, 4, 5}   #补集：返回一个新集合，仅包括集合 x 和 y 中的不同元素

四、条件判断

if ...if   与 if ....elif 的区别：前者不管条件是否成立都会依次进行判断，不会跳出条件判断；后者只要条件成立立即跳出判断，不会再执行后面判断语句。

三元表达

表达语法是：表达式 1 if 条件表达式 else 表达式 2；

当条件为 True 时，返回结果表达式 1，否则返回结果表达式 2。

例子1：

x = 100

print('A') if x > 100 else print('B')

# 如果 if 语句满足条件，执行 if 前语句，否则执行 else 后语句，

# 因为 x=100 ,不满足 if 条件，故执行执行 else 后语句，返回 B 。

例子2：

x = 100

print(('B','A')[x == 100])

# (x,y), x 为 else 后执行语句，y 为 if 满足条件执行语句，

# 因为 x=100 ，满足 if 条件，故执行括号第二参数 ，返回 A 。

例子3：

x = 100

print({True:'A',False:'B'}[x == 100])

# 以字典形式传入判断条件满足执行键值，

# 因为 x==100 条件成立即为 True ，故返回 A

match ....case   python3.10新增，match 后的对象会依次与 case 后的内容进行匹配，如果匹配成功，则执行匹配到的表达式，否则直接跳过，_ 可以匹配一切。

x = 200
match x:           # 设置判断对象 。
    case 100:
        print(1)
    case 200:      # 当条件满足 x = 200 时执行打印语句返回 2 。
        print(2)
    case _:        # 注意case 和 _ 中间有一个空格 。
        print(3)

例子2：

x = 100
match x:
    case 100|200:  # 也可以设置多个判断，条件用 | 进行分割，
        print(1)   # 当 x = 100 or 200 都会执行打印返回 1 。 
    case 300:
        print(2)
    case _:
        print(3)

contimue

continue语句用来跳过当前循环的剩余语句，然后继续进行下一轮循环。

# while......continue语句
 
x = 0
while x < 5:
    x += 1
    if x == 4:
        continue
    else:
        print(x)   
# 依次打印 1 2 3 5，因为当 x = 4 时执行if判断中语句continue，
# 跳过当前循环，执行下一个循环，所以不会执行else中语句故不会打印x值。
 
# for......continue语句
 
for x in range(1,6):
    if x == 4:
        continue
    else:
        print(x)
# 依次打印 1 2 3 5，因为当 x = 4 时执行if判断中语句continue，
# 跳过当前循环，执行下一个循环，所以不会执行else中语句故不会打印x值。

break用来终止循环语句，即循环条件没有 False 条件或者序列还没被完全循环完成，也会停止执行循环语句。

# while......break
 
x = 0
while x < 5:
    x += 1
    if x == 4:
        break
    else:
        print(x)  
# 依次打印 1 2 3 ，因为当 x = 4 时执行 if 判断中语句 break ，跳过出循环，
# 不再执行下一个循环，所以不会执行剩余语句和 else 中语句，故不会打印 x 值。
 
# for......break
 
for x in range(1,6):
    if x == 4:
        break
    else:
        print(x)
# 依次打印 1 2 3 ，因为当 x = 4 时执行 if 判断中语句 break ，跳过出循环，
# 不再执行下一个循环，所以不会执行剩余语句和 else 中语句，故不会打印 x 值。