Python快速入门（1）常用容器和内置函数介绍

参考书目：董付国《python数据分析、挖掘与可视化》 

目录

一、 列表、元组、字典和集合的定义

二、 字符串

三、运算符

3.1  算术运算符

3.2  成员关系运算符

3.3 成员测试运算符

3.4 集合运算符

3.5 逻辑运算符

四、 常用的内嵌函数

4.1 类型转换

4.1.1 int(), float(), complex()

4.1.2 进制数转换

4.1.3 编码和字符转换

4.1.4 常用容器转换

4.1.5 eval函数（常用）

4.2 最大值、最小值 

4.3 元素数量、求和

4.4 排序、逆序

4.4.1 sorted()

4.4.2 reversed()

4.5 输入输出

4.6 range( )

4.7 zip( )

4.8 map()、reduce()和filter() 

4.8.1 map()

4.8.2 reduce（）

4.8.3 filter()

五、综合练习

1.输出个位数字之和

2. 翻转输入的字符串

3. 输出用户输入的列表中的最大值

4. 整数和字符串的转换

5. 输出等价为True的元素列表

6. 按规则排序

其他知识点小总结

 print函数

二进制与字符编码

保留字 

变量

字符串类型

类型转换

---

一、 列表、元组、字典和集合的定义

#分别创建列表，元组，字典和集合
x_list = [1,2,3]
x_tuple = (1,2,3)
x_dict = {'a':97,'b':98,'c':99}
x_set={1,2,3}

#输出列表的第2个元素，下标从0开始
print(x_list[1])

#输出元组的第2个元素
print(x_tuple[1])

#输出字典中键为a的对应的值
print(x_dict['a'])

#输出列表的长度
print(len(x_list))

#输出元组中元素2首次出现的位置
print(x_tuple.index(2))

#输出字典中值为98的对应的键的内容
for key,value in x_dict.items():
    if value==98:
        print(key)

#输出集合中最大的元素
print(max(x_set))

2
2
97
3
1
b
3

二、 字符串

字符串可以使用单引号、双引号和三引号进行定义，使用三引号可以允许字符串内容换行。

在字符串前加r可以直接输出原始字符串，不会再进行转义，因此若字符串中需要出现斜线等有转义符意思的斜线，则可以直接使用r进行原字符串输出。

#字符串可以使用单引号、双引号和三引号进行定义，使用三引号可以允许字符串内容换行
text='''Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Really counts.
'''

#输出字符串的长度
print(len(text))

#统计字符串中is的个数
print(text.count('is'))

#是否存在该单词
print('beautiful' in text)

#输出20个=
print('='*20)

#使用+连接两个字符串进行输出
print('Good' + 'Morning')

#在字符串前加一个r表示原始字符串，无需进行转义
print(r'C:\Desktop\text.txt')

204
6
False
====================
GoodMorning

C:\Desktop\ext.txt

三、运算符

3.1  算术运算符

+：加法运算，连接字符串

-：减法运算，集合间求差集的运算

*：可以生成新的列表、元组等，可表示序列的重复

/，// ：除法，//向下取整

%：求余运算，格式化字符串

**：幂运算

#2.1 算术运算符

print("运算符+")
# 运算法+可以用来连接字符串，列表，元组等等
print('abc'+'def')
print([1,2]+[3,4])
print((1,2)+(3,))
print('\n')

print("运算符-")
# 运算符-可以用来计算集合的差集
print({1,2,3}-{3,4,5})
print({3,4,5}-{1,2,3})
print('\n')

print("运算符*")
#可用于列表、元组、字符串等类型对象与整数的乘法，表示序列元素的重复，生成新的列表，元组或字符串
print('important things should be emphasised by 3 times\n'*3)
#生成新的列表，包含3个0
print([0]*3)
#生成新的元组，包含5个0
print((0,)*5)
print('\n')

print("运算符/和//")
#用来计算除法，//是向下取整
print(17/4)
print(17//4)
print((-17)/4)
print((-17)//4)
print('\n')

print("运算符%")
#可以进行求余运算，也可以用来格式化字符串
print(365%7)
#把65,97,48格式化为字符
print('%c,%c,%c'%(65,97,48))
print('\n')

print('**运算符:幂运算')
print(2**4)
print(3**3**3)
print((3**3)**3)
print(9**0.5)
print((-1)**0.5)
print('\n')

运算符+
abcdef
[1, 2, 3, 4]
(1, 2, 3)

运算符-
{1, 2}
{4, 5}

运算符*
important things should be emphasised by 3 times
important things should be emphasised by 3 times
important things should be emphasised by 3 times

[0, 0, 0]
(0, 0, 0, 0, 0)

运算符/和//
4.25
4
-4.25
-5

运算符%
1
A,a,0

**运算符:幂运算
16
7625597484987
19683
3.0
(6.123233995736766e-17+1j)

3.2  成员关系运算符

用于比较两个对象之间值的大小，可适用于列表、元组或字符串等。

#等价于判断： 3==3 and 3>2
print(3==3>2)

#aASCII码值>A，所以直接得出结论
print('abc'>'ABCD')

#列表第一个元素85>11
print([85,101]>[11,200,65])

#集合1不是集合2的子集
print({1,2,3,4}<={3,4,5})

#元组中前3个元素相同，第一个元组元素更多
print((1,2,3,4)>(1,2,3))

True
True
True
False
True

3.3 成员测试运算符

成员测试运算符in用于测试一个对象是否包含另一个对象，适用于列表、资源组、字典、集合、字符串，以及range对象、zip对象、filter对象等包含多个元素的容器类对象。 

print('成员测试运算符in')
print(60 in [70,60,50,80])

print('abc' in 'a1b2c3d4')

print([3] in [[3],[4],[5]])

print('3' in map(str,range(5)))

print(4 in range(5))
print(5 in range(5))

print(4 in list(range(5)))

成员测试运算符in
True
False
True
True
True
False
True

 

3.4 集合运算符

集合交集：&

并集：|

对称差集：^

差集：- 

print("集合运算符")
A={35,45,55,65,75}
B={65,75,85,95}
#交集运算
print(A|B)
#并集运算
print(A&B)
#差集
print(A-B)
print(B-A)
#对称差集
print(A^B)

{65, 35, 75, 45, 85, 55, 95}
{65, 75}
{35, 45, 55}
{85, 95}
{35, 45, 85, 55, 95}

3.5 逻辑运算符

and：两个表达式都为true时才为true，否则为false

or：两个表达式一个为true就为true，两个都为false才为false

False: 0, 0.0, 0j, None, False, 空列表，空元组，空字符串，空字典，空集合，空range对象或者其他空的容器对象

True：除了false的其他都是true

print("逻辑运算符")
print(3 in range(5) and 'abc' in 'abcdefg')
print(3-3 or 5-2)
#空值等价于false
print(not 5)
#非空列表等价于true
print(not [])

True

3

False

True

 

 

四、 常用的内嵌函数

4.1 类型转换

4.1.1 int(), float(), complex()

数值类型的相互转换

#1. 数字类型转换
print(int(3.5))
print(int('119'))
print(int('1111',2))
print(int('1111',8))
print(int('1111',16))
print(int('   9\n'))
#把字符串转换为浮点数
print(float('3.1415926'))
#复数的转换
print(complex(3,4))
print("\n")

3
119
15
585
4369
9
3.1415926
(3+4j)

 

4.1.2 进制数转换

bin()：把整数转换为二进制数

oct()：把整数转换为十进制数

hex() ：把整数转换为十六进制数

#2. 进制类型转换
print(bin(8888))  #把整数转换为二进制数
print(oct(8888))  #把整数转换为八进制数
print(hex(8888))  #把整数转换为十六进制数
print("\n")

0b10001010111000
0o21270
0x22b8

 

4.1.3 编码和字符转换

 ord()：返回单个字符的Unicode编码

chr()：返回Unicode编码对应的字符

str()：将任意类型的参数转换为字符串

#3. 编码和字符转换
print(ord('a'))   #返回字符的ASCII编码
print(ord('马'))  #返回汉字字符的Unicode编码
print(chr(65))    #返回指定ASCII码对应的字符
print(chr(39532)) #返回指定Unicode编码对应的汉字
print(str([1,2,3,4,5]))  #把列表转换为字符串
print(str({1,2,3,4,5}))  #把集合转换为字符串
print("\n")

97
39532
A
马
[1, 2, 3, 4, 5]
{1, 2, 3, 4, 5}

4.1.4 常用容器转换

创建列表、元组、集合、字典 

注意：转换为集合时会自动去重

print(list(),tuple(),dict(),set()) #建立空的列表、元组、字典和集合
s={3,2,1,4}
print(list(s),tuple(s)) #把集合转换为列表和元组
lst=[1,2,3,3,4,5]
print(set(lst),tuple(lst)) #把列表转换为集合和元组，集合会自动去除重复的元素
print(str(lst)) #把列表转换为字符串，会在每个等号后面自动加一个空格
print(list(str(lst))) #把字符串转换为列表
print(dict(name='Ma',sex='Female',age='21')) #建立字典
print("\n")

[] () {} set()
[1, 2, 3, 4] (1, 2, 3, 4)
{1, 2, 3, 4, 5} (1, 2, 3, 3, 4, 5)
[1, 2, 3, 3, 4, 5]
['[', '1', ',', ' ', '2', ',', ' ', '3', ',', ' ', '3', ',', ' ', '4', ',', ' ', '5', ']']
{'name': 'Ma', 'sex': 'Female', 'age': '21'}

 

4.1.5 eval函数（常用）

可以用来计算字符串或者字节串的值，也可以实现类型转换，得到字符串中数据的实际类型，如用户输入了列表，经过input函数会转换为字符串，但是使用eval函数可以还原成列表 

#5. eval():计算字符串或者字节串的值
print(eval('3+4j'))  #对字符串求值得到负数
print(eval('8**2')) #对字符串求值得到8**2=16
print(eval('[1,2,3,4,5,6]')) #对字符串求值得到列表
print(eval('{1,2,3,4}')) #对字符串求值得到集合
print("\n")

(3+4j)
64
[1, 2, 3, 4, 5, 6]
{1, 2, 3, 4}

lst即为一个列表对象 

lst=eval(input('请输入一个列表：'))

4.2 最大值、最小值 

max和min函数用来求序列中所有元素的最大值和最小值，其中输入的参数可以是列表list、元素tuple、字典dict、集合set或其他包含有限个数元素的可迭代对象。

高级用法：使用key参数规定排序规则，key可以等于函数、lamba表达式等可调用对象。

 max/min(args,key=***)

 

可迭代对象：

(60条消息) 什么是python中的可迭代对象（iterable object）？_梧桐雪的博客-CSDN博客_可迭代对象是什么意思 在python中，可迭代对象包括列表、元组、字典、字符串；我们常结合for循环使用。所以这里的迭代有一定的意思就是能够放在 for i in 后面的元素了。我们其实也可以把这种类型的元素认为是一种容器，最粗浅的理解，就是可以存放很多类型数据的盒子。

 lamba表达式：

相当于一个函数，想要使用函数但是不想定义的时候就可以使用（后期再补充）

(60条消息) Python中lambda表达式学习_imzoer的博客-CSDN博客

 

#最大值、最小值
data = [3,22,111]
print(data)
print(max(data))
print(min(data))
#输出转换为字符串后的最大值，为字符3
print(max(data,key=str))

data = ['3','44','111']
print(max(data))
#返回最大长度的字符串
print(max(data,key=len))

data=['abc','Abcd','ab']
print(max(data))
print(max(data,key=len))
#返回全部转换为小写后最大长度的字符串
print(max(data,key=str.lower))

data=[1,1,2,3,2,2,1,3,1]
#统计列表中数字出现次数频率最大的数字,count方法仅限列表使用
print(max(set(data),key=data.count))
#统计最大元素的位置，getitem方法仅限列表使用
print(max(range(len(data)),key=data.__getitem__))
print("\n")

[3, 22, 111]
111
3
3
44
111
abc
Abcd
Abcd
1
3

4.3 元素数量、求和

len()：计算序列长度

sum()：计算序列中所有元素之和

注意：在字典中使用sum时，是对字典的键求和，而不是键对应的值 

# 元素数量，求和
data = [1,2,3,4]
print(len(data))
print(sum(data))
data = (1,2,3)
print(len(data))
print(sum(data))
data='I love you baby'
print(len(data))
data={97:'a',65:'b',48:'0'}
print(len(data))
#对字典的键求和
print(sum(data))
print("\n")

4
10
3
6
15
3
210

4.4 排序、逆序

4.4.1 sorted()

sort函数可以对可迭代对象进行排序并且返回新列表。

• 支持使用key进行规则排序，key可以是函数、lamba表达式等可调用对象 
• 还可以使用reverse参数指定是升序（reverse=False）还是降序排序（reverse=True），若不指定，则默认为升序排序

shuffle为随机打乱顺序 

#1. 排序
from random import shuffle
data = list(range(20))
shuffle(data)
print(data)
print(sorted(data))
print(sorted(data,key=str))
print(sorted(data,key=str,reverse=True))
print("\n")

[16, 19, 17, 14, 3, 5, 1, 7, 0, 12, 18, 11, 10, 6, 13, 9, 8, 2, 15, 4]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
[0, 1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 3, 4, 5, 6, 7, 8, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 1, 0]

 

4.4.2 reversed()

reversed(）可以对可迭代对象（生成器对象何具有惰性求值的zip、map、enumerate、reversed对象除外）进行翻转并返回可迭代的reversed对象。

注意：reversed对象具有惰性求值特点，其中的元素只能使用一次，不支持使用内置函数len（）进行元素个数的统计，也不支持使用内置函数reversed（）进行再次翻转。

 

 惰性求值：惰性求值不要求你事先准备好整个迭代过程中所有的元素。迭代器仅仅在迭代至某个元素时才计算该元素，而在这之前或之后，元素可以不存在或者被销毁

(60条消息) Python中的优化：惰性求值详解_Charles.zhang的博客-CSDN博客_python惰性求值

 

#2. 逆序
data1= list(range(20))
shuffle(data1)
print(data1)
reversedD = reversed(data1)
print(reversedD)
print(list(reversedD))
#空，因为reversed对象只能使用一次
print(tuple(reversedD))

[8, 3, 16, 9, 7, 18, 5, 1, 17, 4, 12, 0, 2, 13, 15, 19, 10, 11, 14, 6]

[6, 14, 11, 10, 19, 15, 13, 2, 0, 12, 4, 17, 1, 5, 18, 7, 9, 16, 3, 8]
()

 

4.5 输入输出

input函数：

无论用户输入什么内容，input() 一律返回字符串，需要使用int()、float()、eval()等函数对用户输入的内容进行类型转换。 

num=int(input('请输入一个大于2的自然数：'))
if num%2==0:
    print('这是一个偶数')
else:
    print('这是一个奇数')

lst=eval(input('请输入一个包含若干大于2的自然数的列表：'))
print('列表中的所有元素之和为：'+sum(lst))

print函数： 

print(1,2,3,4,5,sep=',') #以逗号进行分割
print(1,2,3,4,5,end=' ') #以空格结尾，不换行
print(6,8,7)

4.6 range( )

range对象可以转换为列表、元组或集合 ，可以使用for循环直接遍历其中的元素，支持下标和切片。

range1 = range(4)
#数字5-7
range2= range(5,8)
#从数字3开始，每次+4，要小于20
range3=range(3,20,4)
#从数字20开始，每次-3，要大于0
range4=range(20,0,-3)
#打印range对象
print(range1,range2,range3,range4)
#打印对应下标的range值
print(range4[2])
#把range对象转换为列表
print(list(range1))
print(list(range2))
print(list(range3))
print(list(range4))
#使用for循环遍历range对象
for i in range(10):
    print(i,end=' ')

range(0, 4) range(5, 8) range(3, 20, 4) range(20, 0, -3)
14
[0, 1, 2, 3]
[5, 6, 7]
[3, 7, 11, 15, 19]
[20, 17, 14, 11, 8, 5, 2]
0 1 2 3 4 5 6 7 8 9 

4.7 zip( )

 zip把多个可迭代对象中对应位置上的元素分别组合到一起，返回一个可迭代的zip对象，最终组合成的元素个数取决于参数序列中更短的那个。

可以把zip对象转换为列表或元组之后查看其中的内容，也可以使用for循环逐个遍历其中的元素。

注意：zip对象中每个元素只能使用一次，不能使用下标访问指定位置的元素，zip不支持切片操作，也不能作为len（）和reversed（）的参数。 

#zip函数
data = zip('1234',[1,2,3,4,5,6])
print(data)
print(list(data))
#使用过一次zip对象后，zip对象中不再包含任何元素，如果想再次使用，需要重新定义zip对象
print(list(data))

data = zip('1234',[1,2,3,4,5,6])
print(tuple(data))

data = zip('1234',[1,2,3,4,5,6])
for i in data:
    print(i)

[('1', 1), ('2', 2), ('3', 3), ('4', 4)]
[]
(('1', 1), ('2', 2), ('3', 3), ('4', 4))
('1', 1)
('2', 2)
('3', 3)
('4', 4)

 

4.8 map()、reduce()和filter() 

4.8.1 map()

map函数中传入的参数需要是可迭代类型。

如果是想要传入int型则错误，因为int不可迭代 

 map作用：

可以实现类型转换，可以转换为列表、元组或者集合，也可以使用for循环遍历其中的元素。

map对象中的元素只能使用一次。

from operator import add
m=map(str,range(5))
m1=map(int,range(10))
print(m)
print(m1)
print(list(m),'\n',list(m1))
#空，只能使用一次
print(tuple(m1))
print(list(map(len,['abc','12345','58fdsa'])))
#把字符串转换为整形列表
print(list(map(int,'12345')))
#把整数列表转换为字符串列表
print(list(map(str,[1,2,3,4,5])))
#相加，遍历
for num in map(add,range(5),range(5,10)):
    print(num)

 

4.8.2 reduce（）

需导入才能使用

from functools import reduce

reduce可以进行叠加运算，如累加、累乘等。 

from functools import reduce
from operator import add,mul,or_

seq=range(1,10)
#对seq中的元素进行累加操作
print(reduce(add,seq))
#对seq的元素进行累乘操作
print(reduce(mul,seq))
seq=[{1},{2},{3},{4}]
#对seq中的集合使用并集运算
print(reduce(or_,seq))
#拼接列表中的元素
lst=['1','2','3','4','5']
print(reduce(add,lst))

45
362880
{1, 2, 3, 4}
12345

 

4.8.3 filter()

使用制定规则对序列中的元素进行过滤。

每个元素只能使用一次。

seq = ['abcd','1234','.?,/','']
print(list(filter(str.isdigit,seq)))
print(list(filter(str.isalpha,seq)))
print(list(filter(str.isalnum,seq)))
print(list(filter(None,seq)))

['1234']
['abcd']
['abcd', '1234']
['abcd', '1234', '.?,/']

 

五、综合练习

1.输出个位数字之和

• map的使用

num=input('请输入一个正整数：')
m=map(int,num)
print('该正整数各位数字之和为：',sum(m))

• reduce的使用 

from functools import reduce
from operator import add
m=list(map(int,input()))
print(reduce(add,m))

 

2. 翻转输入的字符串

• join函数分割字符串

num=input('请输入一个字符串:')
r=list(reversed(num))
print("".join(r))

• 使用reversed对象

from functools import reduce
from operator import add
t=input('请输入一个字符串：')
print(reduce(add,reversed(t)))

 

3. 输出用户输入的列表中的最大值

max函数和eval函数的使用 

lst = eval(input())
print(max(lst))

4. 整数和字符串的转换

输入一个包含若干整数的列表，把列表中国的所有整数转换为字符串，然后输出包含这些字符串的列表

lst = list(map(str,input()))
print(lst)

5. 输出等价为True的元素列表

输入一个包含若干任意元素的列表，输出该列表中等价于True的元素组成的列表。如输入[1,2,0，None，False，‘a’]，输出['1', '2', 'a']

lst = eval(input())
print(list(filter(None,lst)))

 

6. 按规则排序

输入一个包含若干整数的列表，输出一个新列表，新列表中奇数在前偶数在后，并且奇数之间的相对顺序不变，偶数之间的相对顺序也不变

lst = eval(input())
newL = sorted(lst,key=lambda num:num%2==0)
print(newL)

其他知识点小总结

 print函数

 创建文件并写入内容

a+：如果文件存在就在文件里追加内容，如果文件不存在就创建一个新文件，然后写入内容 

fp=open('G:/text.txt','a+')
print("helloworld",file=fp)
fp.close()

二进制与字符编码

在ASCII码中，计算机中8位（一个字节）可以表示256种状态，ASCII码可以表示0-127即128个字符，剩下的128个不够用，所以推出了不同的字符集，如GB2312,GBK，GB18030

Unicode：为了统一各国不同的编码规则

utf-8：中文3个字节，英文1个字节

Unicode：中文英文都用2个字节

例子：

乘的Unicode编码为4e58，转换为十进制为20056，二进制为 100111001011000

chr()函数是Python中的一个库函数，用于从给定的ASCII码 (整数值)中获取字符值，它接受一个数字(应为ASCII码 )并返回字符。

ord()函数是Python中的一个库函数，用于从给定字符值中获取数字值，它接受一个字符并返回一个整数，即用于将字符转换为整数，即用于获取ASCII给定字符的值 。

print(chr(0b100111001011000))
print(ord('乘'))

乘
20056

保留字 

# 保留字
import keyword
print(keyword.kwlist)

变量

name='winnie'
print('值',name)
print('标识',id(name))
print('类型',type(name))

浮点数相加不准确原因：

计算机以二进制存储，有些情况会出现浮点数相加不准确的情况。

from decimal import Decimal

print(1.1+2.2)

print(Decimal('1.1')+Decimal('2.2'))

字符串类型

三引号效果：

str = 'Jet lag'
str2='''
今天
天气
好晴朗
'''
print(str2)

类型转换

name='winnie'
age=21
# print('我叫'+name+'今年'+age+'岁')  #错误，因为name和age的类型不一样，不能一起输出
print('我叫'+name+'今年'+str(age)+'岁')