目录
[11. 随机数random()](#11. 随机数random())
[13. 按指定基数递增的集合中获取一个随机数randrange ([start,] stop [,step])](#13. 按指定基数递增的集合中获取一个随机数randrange ([start,] stop [,step]))
[14. 将序列的所有元素随机排序shuffle()](#14. 将序列的所有元素随机排序shuffle())
11.判断子字符串是否包含在字符串中find(str,beg=0,end=len(string))
[12. 寻找字符串下标](#12. 寻找字符串下标)
[18.返回长度为 width 的字符串,原字符串右对齐,前面填充0](#18.返回长度为 width 的字符串,原字符串右对齐,前面填充0)
(一)数值函数
1.绝对值abs(x)
python
print(abs(-9.6)) # 9.6
2.最大值max(x1,x2...)
python
print(max(32, -9, 89)) # 89
3.最小值min(x1,x2...)
python
print(min(32, -9, 89)) # -9
4.向上取整math.ceil(x)
python
print(math.ceil(-5.8), math.ceil(5.3)) # -5 6
5.向下取整math.floor(x)
python
print(math.floor(-5.8), math.floor(5.8)) # -6 5
6.返回e的x次幂math.exp(x)
python
print(math.exp(1)) # 2.718281828459045
7.返回x的整数部分与小数部分modf(x)
python
print(math.modf(9.6)) # (0.5999999999999996, 9.0)
8.x**y的值math.pow(x)
python
print(math.pow(2, 3)) # 8.0
9.四舍五入round(x)
python
print(round(-9.8), round(9.8)) # -10 10
10.求平方根math.sqrt(x)
python
print(math.sqrt(121)) # 11.0
11. 随机数random()
python
print(random()) # 0.7661687961118427
print(math.ceil(random() * 10)) # 3
12.从指定范围内随机挑选random.choice()
python
print(random.choice(range(100))) # 96
print(random.choice([8, 5.6, -4, 55])) # 5.6
print(random.choice('hello world')) # e
13. 按指定基数递增的集合中获取一个随机数randrange ([start,] stop [,step])
python
# 从1~99内获取奇数
print(random.randrange(1, 99, 2)) # 93
# 从0~100之间获取随机数
print(random.randrange(100)) # 13
14. 将序列的所有元素随机排序shuffle()
python
list1 = [20, 8, 6, 77]
random.shuffle(list1)
print(list1) # [77, 8, 20, 6]
15.三角函数
python
print(math.cos(0), math.cos(math.pi)) # 1.0 -1.0
print(math.sin(0)) # 0.0
print(math.tan(0)) # 0.0
(二)字符串函数
1.字符串取值取下标
python
string = 'hello'
print(string[1],string[2:4]) # e ll
2.字符串长度
python
print(len('java hadoop')) # 11
3.全部转为小写
python
print(str.lower('JAVA HADOOP')) # java hadoop
4.全部转为大写
python
print(str.upper('java hadoop')) # JAVA HADOOP
5.整个字符串首字母大写(字符串"标题化")
python
print(str.capitalize('JAVA HADOOP')) # Java hadoop
6.单词首字母大写
python
print(str.title('java hadoop')) # Java Hadoop
7.字符串大小写互转
python
print(str.swapcase('javA hadOOP')) # JAVa HADoop
8.字符串填充
python
print(str.center('Java hadoop', 20, '*')) # ****Java hadoop*****
print(str.ljust('Java hadoop', 20, '*')) # Java hadoop*********
print(str.rjust('Java hadoop', 20, '*')) # *********Java hadoop
9.判断子字符串在字符串中出现的次数
语法:str.count(sub, start= 0,end=len(string))
参数
- sub -- 搜索的子字符串
- start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
- end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
python
string = '****Java hadoop*****'
print(string.count('*')) # 9
print(string.count('*', 3, 10)) # 1
10.判断字符串开头/结尾
python
string = '****Java hadoop*****'
print(string.startswith('/')) # False
print(string.endswith('*')) # True
print(string.endswith('*', 1, 4)) # True
print(string.endswith('*', 3, 6)) # False
11.判断子字符串是否包含在字符串中find(str,beg=0,end=len(string))
检测 str 是否包含在字符串中,如果指定范围 beg 和 end ,则检查是否包含在指定范围内,如果包含返回开始的索引值,否则返回-1
python
string = '****Java hadoop*****'
print(string.find('*',3,10)) # 3
print(string.rfind('*')) # 19
12. 寻找字符串下标
与find方法一样,但是如果str不在字符串中会报异常
python
print(string.index('a')) # 5
print(string.rindex('a')) # 10
13.字符串指定拼接join
python
str1 = '-'
str2 = 'world'
print(str1.join(str2)) # w-o-r-l-d
14.字符串去除空格
python
print(str.strip(' java ')) # java
print(str.lstrip(' java ')) # java
print(str.rstrip(' java ')) # java
15.字符串中最大/最小的字母
python
print(max('zhello'),min('zhello')) # z e
16.替换字符串中的内容
python
print(str.replace('hello', 'l', '*')) # he**o
17.字符串分割
python
string2 = 'Java hadoop spark flink mysql'
# 以空格为分隔符
print(string2.split(' ')) # ['Java', 'hadoop', 'spark', 'flink', 'mysql']
# 以a为分隔符,分割2次
print(string2.split('a',2)) # ['J', 'v', ' hadoop spark flink mysql']
# 以a为分隔符
print(string2.split('a')) # ['J', 'v', ' h', 'doop sp', 'rk flink mysql']
18.返回长度为 width 的字符串,原字符串右对齐,前面填充0
python
string = '****Java hadoop*****'
print(string.zfill(25)) # 00000****Java hadoop*****
(三)列表函数
1.列表取值取下标
python
list = ['java','hadoop','spark','flink']
print(list[1:3],list[-3:-2], list[2:])
# ['hadoop', 'spark'] ['hadoop'] ['spark', 'flink']
2.列表拼接
python
list = ['java','hadoop','spark','flink']
list.append('flume')
print(list) # ['java', 'hadoop', 'spark', 'flink', 'flume']
list1 = ['hello','world']
list += list1
print(list) # ['java', 'hadoop', 'flink', 'flume', 'hello', 'world']
list2 = [list,list1] # 类似二维数组
print(list2)
# [['java', 'hadoop', 'flink', 'flume', 'hello', 'world'], ['hello', 'world']]
print(list2[0],list2[1][1])
# ['java', 'hadoop', 'flink', 'flume', 'hello', 'world'] world
list1.extend('oracle')
print(list1) # ['hello', 'world', 'o', 'r', 'a', 'c', 'l', 'e']
list1.insert(3,'2233')
print(list1) # ['hello', 'world', 'o', '2233', 'r', 'a', 'c', 'l', 'e']
3.删除列表元素
python
list = ['java','hadoop','spark','flink']
del list[2]
print(list) # ['java', 'hadoop', 'flink', 'flume']
# 移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
list1 = ['java', 'hadoop', 'flink', 'flume', 'hello', 'world']
list1.pop()
print(list1) # ['java', 'hadoop', 'flink', 'flume', 'hello']
list1 = ['java', 'hadoop', 'flink', 'flume', 'hello', 'world']
list1.pop(2)
print(list1) # ['java', 'hadoop', 'flume', 'hello', 'world']
# 移除列表中某个值的第一个匹配项
list1 = ['java', 'hadoop', 'flink', 'flume', 'hello', 'world']
list1.remove('flume')
print(list1) # ['java', 'hadoop', 'flink', 'hello', 'world']
Python 表达式 | 结果 | 描述 |
---|---|---|
len([1, 2, 3]) | 3 | 长度 |
[1, 2, 3] + [4, 5, 6] | [1, 2, 3, 4, 5, 6] | 组合 |
['Hi!'] * 4 | ['Hi!', 'Hi!', 'Hi!', 'Hi!'] | 重复 |
3 in [1, 2, 3] | True | 元素是否存在于列表中 |
for x in [1, 2, 3]: print(x, end=" ") | 1 2 3 | 迭代 |
4.判断列表内容是否一致
python
import operator
list1 = ['a', 'b']
list2 = ['a', 'b']
list3 = ['a']
print(operator.eq(list1, list2), operator.eq(list1, list3)) # True False
5.返回列表个数
python
list1 = ['java', 'hadoop', 'flink', 'flume', 'hello', 'world']
print(len(list1)) # 6
6.返回列表的最大/最小值
python
list1 = [-9, 6, 78, 5.2]
print(max(list1), min(list1)) # 78 -9
7.统计某个元素在列表中出现的次数
python
list1 = ['java', 'hadoop', 'flink', 'flume', 'hello', 'java']
print(list1.count('java')) # 2
8.判断列表元素的索引位置
python
list1 = ['java', 'hadoop', 'flink', 'flume', 'hello', 'java']
print(list1.index('hadoop')) # 1
9.列表元素反转
python
list1 = ['java', 'hadoop', 'flink', 'flume', 'hello', 'world']
list1.reverse()
print(list1) # ['world', 'hello', 'flume', 'flink', 'hadoop', 'java']
10.列表元素排序
python
list1 = [-9.4,-55,78,999]
list1.sort()
print(list1) # [-55, -9.4, 78, 999]
11.清空列表list.clear
12.复制列表list.copy
(四)元组函数
1.元组的形式
>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d" # 不需要括号也可以
>>> type(tup3)
<class 'tuple'>
2.创建空元组
tup1=()
元组中只包含一个元素时,需要在元素后面添加逗号 , ,否则括号会被当作运算符使用:
>>> tup1 = (50)
>>> type(tup1) # 不加逗号,类型为整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗号,类型为元组
<class 'tuple'>
3.访问元组中的元素与字符串相同,取下标
Python 表达式 | 结果 | 描述 |
---|---|---|
tup[1] | 'Runoob' | 读取第二个元素 |
tup[-2] | 'Weibo' | 反向读取,读取倒数第二个元素 |
tup[1:] | ('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin') | 截取元素,从第二个开始后的所有元素。 |
tup[1:4] | ('Runoob', 'Taobao', 'Wiki') | 截取元素,从第二个开始到第四个元素(索引为 3)。 |
4.判断元组的长度
python
tup1 = ('java','hadoop', 'spark', 'flume')
print(len(tup1)) # 4
5.判断元组内元素的最大/最小值
python
tup1 = ('java','hadoop', 'spark', 'flume')
print(max(tup1),min(tup1)) # spark flume
6.元组中的元素不能修改
(五)字典函数
d = {key1 : value1, key2 : value2, key3 : value3 }由键值对组合而成
键必须是唯一的,但值则不必。
值可以取任何数据类型,但键必须是不可变的,如字符串,数字。
1.访问字典的数据------通过键访问
python
# 返回指定键的值
dict1 = {'name':'zs', 'age':19}
print(dict1['name']) # zs
# 如果dict1后面的键没有,会触发异常
# dict.get(key[, value])
# key -- 字典中要查找的键。
# value -- 可选,如果指定键的值不存在时,返回该默认值。
dict2 = {'name': 'zhangsan', 'age': 10, 'gender': '男'}
print(dict2.get('age')) # 10
print(dict2.get('java')) # None
print(dict2.get('hadoop', '没有这个值!')) # 没有这个值!
# dict.setdefault(key, default=None)函数:当键值不存在,或默认添加到字典中
print(dict2.setdefault('java','键不存在')) # 键不存在
print(dict2)
# {'name': 10, 'age': 10, 'gender': 10, 'java': '键不存在'}
# 嵌套字典
dict3 = {'name': {'name1': 'zs', 'name2': 'ls'}, 'age': {'age1': 18, 'age2': 19}}
print(dict3['name']) # {'name1': 'zs', 'name2': 'ls'}
print(dict3.get('name', {}).get('name2')) # ls
print(dict3.get('age', {}).get('age1')) # 18
2.修改字典
python
dict1 = {'name':'zs', 'age':19}
dict1['name']='ls'
print(dict1) # {'name': 'ls', 'age': 19}
dict2 = {'name': 10, 'age': 10, 'gender': 10}
dict2.update({'class': 'flink'})
print(dict2)
# {'name': 10, 'age': 10, 'gender': 10, 'class': 'flink'}
3.删除字典
python
dict1 = {'name':'zs', 'age':19}
del dict1['name'] # 删除键 'name'
print(dict1) # {'age': 19}
dict1 = {'name':'zs', 'age':19}
dict1.clear() # 清空字典
print(dict1) # {}
dict1 = {'name':'zs', 'age':19}
del dict1 # 删除字典
print(dict1)
# pop(key[,default])
# key - 要删除的键
# default - 当键 key 不存在时返回的值
dict2 = {'name': 'zhangsan', 'age': 10, 'gender': 10}
element = dict2.pop('name')
print('删除的元素为:',element) # 删除的元素为: zhangsan
print('删除后的字典为:',dict2) # 删除后的字典为: {'age': 10, 'gender': 10}
dict2 = {'name': 'zhangsan', 'age': 10, 'gender': 10}
element = dict2.pop('java','不存在的key')
print('删除的元素为:',element) # 删除的元素为: 不存在的key
print('删除后的字典为:',dict2) # 删除后的字典为: {'name': 'zhangsan', 'age': 10, 'gender': 10}
# dict.popitem()
# 返回并删除字典中的最后一对键和值。
dict2 = {'name': 'zhangsan', 'age': 10, 'gender': 10}
dict2.popitem()
print('删除后的字典为:',dict2) # 删除后的字典为: {'name': 'zhangsan', 'age': 10}
4.字典键的特性
1)不允许同一个键出现两次。创建时如果同一个键被赋值两次,后一个值会被记住
python
dict1 = {'name': 'zs', 'name': 'ls'}
print(dict1) # {'name': 'ls'}
2)键必须不可变,所以可以用数字,字符串或元组充当,但不可以用列表
python
dict1 = {1: 'zs', 'name': 'ls',['age']: 18}
print(dict1)
Traceback (most recent call last):
File "*********", line 1, in <module>
dict1 = {1: 'zs', 'name': 'ls',['age']: 18}
TypeError: unhashable type: 'list'
5.输出字典的长度
python
dict1 = {'name': 'zhangsan','age': 22,'gender': '男'}
print(len(dict1)) # 3
6.复制字典dict.copy()
7.创建新字典
python
seq = ('name', 'age', 'gender')
# 不指定值
dict2 = dict.fromkeys(seq)
print(dict2) # {'name': None, 'age': None, 'gender': None}
# 指定值
dict2 = dict.fromkeys(seq, 10)
print(dict2) # {'name': 10, 'age': 10, 'gender': 10}
8.判断键是否存在
python
dict2 = {'name': 'zhangsan', 'age': 10, 'gender': '男'}
if 'name' in dict2:
print('键存在')
else:
print('键不存在') # 键存在
if 'name1' not in dict2:
print('键不存在')
else:
print('键存在') # 键不存在
(六)集合函数
集合(set)是一个无序的不重复元素序列。
可以使用大括号 { } 或者 set() 函数创建集合,注意:创建一个空集合必须用 set() 而不是 { },因为 { } 是用来创建一个空字典。
1.集合可以自动去重
python
set1 = {'java','mysql', 'hadoop', 'spark', 'java'}
print(set1) # {'java', 'spark', 'hadoop', 'mysql'}
2.集合之间的运算
python
a = set('afhduias')
b = set('afhyuias')
# a中有,b中没有
print(a - b) # {'d'}
# a中没有,b中有
print(b - a) # {'y'}
# 集合a或b中包含的所有元素
print(a | b) # {'y', 's', 'd', 'f', 'h', 'a', 'i', 'u'}
# 集合a和b中都包含了的元素------交集
print(a & b) # {'a', 'i', 'u', 'f', 's', 'h'}
# 不同时包含于a和b的元素
print(a ^ b) # {'d', 'y'}
########################################################
# 元素包含在集合 a ,但不在集合 b
a = {'hello', 'world'}
b = {'hello', 'java'}
c = a.difference(b)
d = b.difference(a)
print(a, b) # {'hello', 'world'} {'hello', 'java'}
print(c, d) # {'world'} {'java'}
# difference_update直接在原来的集合中移除元素,没有返回值
a = {'hello', 'world'}
b = {'hello', 'java'}
a.difference_update(b)
print(a, b) # {'world'} {'hello', 'java'}
########################################################
# 返回集合的交集
# intersection()------有返回值
# intersection()_update------没有返回值
#########################################################
symmetric_difference()
3.添加元素add()与update()
python
set1 = {'java','mysql', 'hadoop', 'spark'}
set1.add('flink')
print(set1) # {'spark', 'mysql', 'java', 'hadoop', 'flink'}
set1 = {('java', 'mysql', 'hadoop', 'spark')}
set1.update({1, 2})
set1.update([1, 4], [2, 6])
print(set1) # {1, 2, 4, 6, ('java', 'mysql', 'hadoop', 'spark')}
4.删除集合中的元素
python
set1 = {'java', 'mysql', 'hadoop', 'spark', 'flink'}
set1.remove('mysql')
# 移除指定元素后顺序打乱
print(set1) # {'spark', 'java', 'flink', 'hadoop'}
##########################################################
set1 = {'java', 'mysql', 'hadoop', 'spark', 'flink'}
print(set1) # {'spark', 'mysql', 'java', 'hadoop', 'flink'}
set1.clear()
print(set1) # set()
##########################################################
# difference_update直接在原来的集合中移除元素,没有返回值
a = {'hello', 'world'}
b = {'hello', 'java'}
a.difference_update(b)
print(a, b) # {'world'} {'hello', 'java'}
##########################################################
# discard() 方法用于移除指定的集合元素。
set1 = {'java', 'mysql', 'hadoop', 'spark'}
set1.discard('java')
print(set1) # {'hadoop', 'mysql', 'spark'}
set1 = {'java', 'mysql', 'hadoop', 'spark'}
set1.discard('oracle')
print(set1) # {'mysql', 'java', 'spark', 'hadoop'}
##########################################################
# 随机移除一个元素
c = {'hello', 'java', 'hadoop'}
c.pop()
print(c) # {'hadoop', 'hello'}
##########################################################
# 返回两个集合中不重复的元素集合------有返回值
a = {'hello', 'java', 'mysql'}
b = {'hello', 'world', 'java'}
print(a.symmetric_difference(b)) # {'mysql', 'world'}
print(a, b) # {'mysql', 'hello', 'java'} {'hello', 'world', 'java'}
# 移除当前集合中在另外一个指定集合相同的元素,并将另外一个指定集合中不同的元素插入到当前集合中
a = {'hello', 'java', 'mysql'}
b = {'hello', 'world', 'java'}
a.symmetric_difference_update(b) # 没有返回值
print(a) # {'world', 'mysql'}
5.复制集合copy()
6.返回多个集合的并集union()
python
a = {'hello', 'java', 'mysql'}
b = {'hello', 'world', 'java'}
c = {'zs', 'ls', 'ww'}
d = a.union(b,c)
print(d) # {'mysql', 'ls', 'ww', 'java', 'world', 'hello', 'zs'}
7.判断是否包含元素
python
# isdisjoint() 方法用于判断两个集合是否包含相同的元素,如果没有返回 True,否则返回 False。
a = {'hello1', 'world'}
b = {'hello', 'java'}
c = {'hello', 'java'}
# 判断集合b中是否有包含 集合a的元素
x = a.isdisjoint(b)
# 判断集合c中是否有包含 集合b的元素:
y = b.isdisjoint(c)
print(x, y) # True False
#############################################################
a = {'hello', 'java'}
b = {'hello', 'world', 'java'}
# b是否包含a
print(a.issubset(b)) # True
# b是否完全包含a
print(a.issuperset(b)) # False
##############################################################