python中常用函数（1）

目录

 

1、输出和输入函数

2、常用的类型转换函数

3、序列中的常用函数

4、列表中的常用函数

5、元组中的常用函数

6、字符串中的常用函数

7、字典中的常用函数

8、集合中的常用函数

9、列表、元组、字典和集合的区别

---

1、输出和输入函数

python的内置函数

print()

input()

2、常用的类型转换函数

int(x)

float(x)

str(x)

repr(x) 将x转换为表达式字符串

chr(x)

ord(x) 将一个x转换为它对应的整数值

hex(x) 将一个整数x转换为一个十六进制字符串

oct(x) 将一个整数x转换为一个八进制字符串

3、序列中的常用函数

序列：一块用于存放多个值的连续内存空间；python中的序列结构有列表、元组、集合、字典和字符串。

（1）访问序列中的元素：

方法1，通过索引的方式

方法2，通过切片操作进行访问

s=[1,2,3,4,5,6]

print(s[0:5:2]) #获取第1个、第3个和第5个元素

（2）序列可以相加，要注意类型要一致

（3）序列可以和数字相乘

（4）检查元素是否在序列中

print(value in seq) #return ture or false

（5）计算序列长度、最大值和最小值函数

python的内置函数：

len(seq)

max(seq)

min(seq)

（6）其他的有关序列的内置函数

list() 将序列转换为列表

str()

sum()

sorted() 对元素进行排序

reversed() 反向序列中的元素

enumerate() 将序列组合成一个索引序列

4、列表中的常用函数

（1）创建

listname=[ele1,ele2,ele3,...,elen]

list(range(10,20,2)) #创建一个10~20，不包括20所有偶数的列表

（2）访问列表元素

同上

（3）遍历列表

方法1，for循环

for item in listname

方法2，for循环配合enumerate函数实现

for index,item in enumerate(listname) #可以输出index和item

（4）操作列表元素的函数

listname.append(obj) 添加元素

listname.extend(seq) 将一个列表中的元素全部添加到另一个列表中

listname[index]=new_value 修改指定元素

del listname[index] 根据索引删除指定元素

if listname.count(value)>0: 根据元素值删除元素，先要判断该元素是否在列表当中；count用于判断value在列表中出现的次数

listname.remove(value)

（5）对列表进行统计计算的函数

listname.count(obj)

listname.index(obj) 获取指定元素在列表中首次出现的位置

sum(listname[start:end]) 统计元素和

（6）对列表进行排序的函数

1、列表对象的sort方法：

listname.sort(key=str.lower,reverse=True) key=str.lower表示不区分子母大小写；reverse=True表示按降序进行排列，默认升序

2、内置的sorted函数：注意，上述的sort方法会改变原列表的排列顺序；而sorted函数，会建立一个原列表的副本，该副本是排序后的列表。

sorted(listname,key=str.lower,reverse=True)

（7）列表推导式：快速生成列表

生成指定范围的数值列表

listname = [random.randint(10,100) for i in range(10)] 生成一个包括10个随机数的列表，数的范围在10到100（包括）之间

5、元组中的常用函数

元组和列表的区别，元组是不可变序列，列表是可变序列；即元组中的元素不可以单独修改，而列表则可以任意修改。

（1）元组的创建

tuplename = (ele1,ele2,ele3,...,elen)

（2）访问元组元素

tuplename[index]

（3）修改元组元素，要整体修改

p1 = (1,2,3,4)

p1 = (1,3,3,4)

print(p1) #结果为(1,3,3,4)

（4）元组推导式快速生成一个元组

randomnumber = (random.randint(10,100) for i in range(10)) 注意，元组推导式生成的结果是一个生成器对象

randomnumber = tuple(randomnumber) 可将这个对象通过tuple方法转换成一个元组

_next()_是遍历生成器对象的方法，注意遍历后原生成器对象就不存在了；如下

number = (i for i in range(3))
print(number.__next__())
number = tuple(number)
print(number)

结果：
0
(1, 2)

6、字符串中的常用函数

（1）字符串拼接

str1+str2

（2）字符串长度

len(str)

（3）截取字符串

str[start:end:step]

（4）分割字符串

str.split(sep,maxsplit) #sep是指按照该分割符进行分割，默认是None，即所有空字符(包括空格、换行符、制表符等)；maxsplit，用于指定分割的次数，不指定或者为-1，则分割次数没有限制

str = '我是>>>你>>>爸>>>爸'
str1 = str.split()
str2 = str.split('>>>')
str3 = str.split('>>>', 2)  # 只分割前2个
print(str1)
print(str2)
print(str3)

结果：
['我是>>>你>>>爸>>>爸']
['我是', '你', '爸', '爸']
['我是', '你', '爸>>>爸']

（5）检索字符串

1、str.count(sub) 检索指定字符串在str中出现的次数

str = '我是你爸爸'
num1 = str.count("爸")
num2 = str.count("爸", 3) #指定检索的开始位置
num3 = str.count("爸", 3, 4) #指定检索的开始位置和结束位置；注意，索引为4的位置未被检测
num4 = str.count("爸", 3, 5)
print(num1)
print(num2)
print(num3)
print(num4)

结果：
2
2
1
2

2、str.find(sub) 存在则返回0，不存在则返回-1；该方法与print(sub in str) 类似，返回true或false

3、str.index(sub) 返回子串首次出现的位置索引

4、str.startwith(sub) 用于检索字符串是否以指定子字符串开头；返回true或false

str.endwith(sub)

（6）字母的大小写转换

str.lower() 大转小

str.upper() 小转大

（7）去除字符串中的空格和特殊字符

1、str.strip(chars) 去除字符串左右两侧的空格和指定字符；设置chars为"@#"，则去除左右两侧的@或#；如果不指定chars参数，则默认去除空格一类的符号。

2、str.lstrip(chars) 去除左侧

str.rstrip(chars) 去除右侧

（8）格式化字符串，预先制定一个模板，在该模板中预留几个空位，然后根据需要填上相应的内容

使用字符串对象的format()方法：str.format(agrs) 其中，str指定字符串的显示样式，args指定要转换的项

str = "我是你爸爸{:s}的{:s}"  # 创建模板需要使用{} 和 ： 指定占位符
context1 = str.format("father", "爸爸")
context2 = str.format("爹地", "father")
print(context1)
print(context2)

结果：
我是你爸爸father的爸爸
我是你爸爸爹地的father

7、字典中的常用函数

 

字典和列表类似，是可变序列，但是和列表不同的是字典是无序的可变序列，保存的内容是以键值对的形式存放的。

（1）字典的创建

1、dictionary = {'key1':'value1', 'key2':'value2', ... , 'keyn':'valuen'}

2、dict()方法，可以用来创建一个空字典

dic1 = dict()  # 生成一个空的字典
print(dic1)

结果：
{}

3、dict()方法，通过映射函数创建字典

list1 = ['a', 'b', 'c']  # 用于生成字典的键
list2 = ['A', 'B', 'C']  # 用于生成字典的值
dic2 = dict(zip(list1, list2))
print(dic2)

# zip()函数，用于将多个列表或元组对应位置的元素组合为元组，并返回包含这些内容的zip对象
z1 = zip(list1, list2)
print(tuple(z1))

z2 = zip(list1, list2)
print(list(z2))

结果：
{'a': 'A', 'b': 'B', 'c': 'C'}
(('a', 'A'), ('b', 'B'), ('c', 'C'))
[('a', 'A'), ('b', 'B'), ('c', 'C')]

4、dict()方法，通过给定的键值对创建字典

dic = dict(a='A', b='B')
print(dic)

结果：
{'a': 'A', 'b': 'B'}

5、使用dict对象的fromkeys()创建值为空的字典

list = ['a', 'b', 'c']
dic = dict.fromkeys(list)
print(dic)

结果：
{'a': None, 'b': None, 'c': None}

6、通过已经存在的元组或列表创建字典

注意：列表不能作为字典的键；

key1 = ('a', 'b')
value1 = ('A', 'B')
dic1 = {key1:value1}
print(dic1)


key3 = ('a', 'b')
value3 = ['A', 'B']
dic3 = {key3:value3}
print(dic3)

结果：
{('a', 'b'): ('A', 'B')}  #元组作为键和值
{('a', 'b'): ['A', 'B']}  #元组作为键，列表作为值

（2）访问字典

dictionary.get(key,[default]) 其中，default用于指定当键不存在时，返回一个默认值

（3）遍历字典

dictionary.items()  可获取字典的键值对列表

dic = {'qq':'123', 'id':'abc'}
for item in dic.items():
    print(item)

for key, value in dic.items():
    print(key,"-----",value)

结果：
('qq', '123')
('id', 'abc')
qq ----- 123
id ----- abc

（4）对字典元素的操作

dictionary[new_key] = value 添加元素

dictionary[key] = new_value 修改元素

if key in dictionary: 删除元素

del dictionary[key]

（5）字典推导式快速生成一个字典

randomdict = {i:random.randint(10,100) for i in range(1,5)} 生成包含4个随机数的字典

8、集合中的常用函数

集合：保存不重复元素；有可变集合set和不可变集合frozenset

（1）集合的创建

1、setname = {ele1, ele2, ele3, ... , elen}

注意：集合是无序的，每次输出的顺序可能会不同

2、set()函数创建集合

setname = set(iteration) iteration表示要转换为集合的可迭代对象，可以是列表，元组，range对象等；也可以是字符串，会返回一个不重复字符的集合；

（2）集合的添加和删除

setname.add(element)

setname.remove(element) 移除指定元素

setname.clear() 清空集合

（3）集合运算：交集，并集和差集

set1 & set2

set1 | set2

set1 - set2

9、列表、元组、字典和集合的区别

 

数据结构	是否可变	是否重复	是否有序	定义符号
列表	可变	可重复	有序	[]
元组	不可变	可重复	有序	()
字典	可变	可重复	无序	{key:value}
集合	可变	不可重复	无序	{}