李某人的笔记
0%

python数据类型

发表于 分类于 ，

学习通过 菜鸟教程：https://www.runoob.com/python3/python3-data-type.html

类型转换

只需要将数据类型作为函数名即可，如int(x) 、float(x)

数字(Number)

  • int：10，py3 中int类型是动态长度的，是长整型，理论支持无限大的数字
  • float： 32.3e+18、 -90.
  • complex： 9.322e-36j

字符串(String)

取值顺序

  • 从左到右索引默认0开始的，左开右闭
  • 从右到左索引默认-1开始的，左开右闭

截取与拼接

1
2
3
4
5
6
7
str = 'Hello World!'
print(str[0])        # H						输出字符串中的第一个字符
print(str[2:5])      # llo 						输出字符串中第三个至第六个之间的字符串
print(str[2:])       # llo World!				输出从第三个字符开始的字符串
print(str * 2)       # Hello World!Hello World!	输出字符串两次
print(str + "TEST")  # Hello World!TEST			输出连接的字符串
print(str[0:4:2])	 # Hl						第三个参数为步长，2（间隔一个位置）来截取字符串

字符串格式化

1
2
# 用 % 
print("My name is %s and weight is %d kg!" % ('Zara', 21))

带开头的字符串

f-string

格式化字符串以f 开头，后面跟着字符串，字符串中的表达式用大括号{}包起来，它会将变量或表达式计算后的值替换进去

1
2
x = 1
print(f'{x+1}')   # 输出 2

原始字符串

1
2
# r'' / R''
print(r'\n',R'\t')   # 输出\n \t

Unicode 字符串

在Python3中，所有的字符串都是16位unicode字符串。在Python2中，需要字符串前面加上前缀 u

常用内建函数

内建函数 描述
len(string) 返回字符串长度
count(str, beg= 0,end=len(string)) 统计子串出现次数
encode(encoding=’UTF-8’,errors=’strict’)
bytes.decode(encoding=”utf-8”, errors=”strict”)		 编码格式转化
find(str, beg=0, end=len(string))/rfind
index(str, beg=0, end=len(string))/ rindex		 寻找子串
find失败返回-1，index失败抛出异常，成功都是返回下标
isdigit()
isnumeric()		 字符串是否只包含数字/数字字符
join(seq) 序列中转字符串，以指定的字符连接
replace(old, new, max) 字符串替换
startswith(substr, beg=0,end=len(string)) 检查字符串开头
upper() / lower() 大/小写转换
split(str=””, num=string.count(str)) / splitlines() 字符串分割

列表(List)

初始化

1
list = [ 'runoob', 786 , 2.23, 'john', 70.2 ]

[]操作列表

1
2
3
4
5
print(list[2])	#访问
list[2] = 2001 	#修改
del list[2]		#删除
nl = list[1:3]  #截取
2001 in list	#查询

列表函数&方法

函数 描述
len(list) 列表元素个数
max(list) 返回列表元素最大值
min(list) 返回列表元素最小值
方法 描述
list.append(obj) 在列表末尾添加新的对象
list.count(obj) 统计某个元素在列表中出现的次数
list.extend(seq) 用新列表扩展原来的列表
list.insert(index, obj) 将对象插入列表
list.pop(index=-1) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj) 移除列表中某个值的第一个匹配项
list.reverse() 反向列表中元素
list.sort( key=None, reverse=False) 对原列表进行排序
list.clear() 清空列表

元组(Tuple)

元组用 ()标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表

1
tuple = ( 'runoob', 786 , 2.23, 'john', 70.2 )

集合(Set)

可以使用大括号 { }或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { }是用来创建一个空字典

1
2
3
4
5
6
7
8
9
sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
a = set('abracadabra')
b = set('alacazam')

print(a)
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

字典(Dictionary)

字典用{ }标识。字典的每个键值 key=>value 对用冒号 : 分割

1
2
3
4
5
6
7
8
9
10
11
dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"
 
tinydict = {'name': 'runoob','code':6734, 'dept': 'sales'}

print(dict['one'])         	# 输出键为'one' 的值
print(dict[2])            	# 输出键为 2 的值
print(tinydict)           	# 输出完整的字典
print(tinydict.keys())      # 输出所有键
print(tinydict.values())   	# 输出所有值

删除字典元素

1
2
3
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典

字典内置方法

方法 描述
dict.clear() 删除字典内所有元素
dict.fromkeys() 序列生成字典的key
key in dict/dict.get(key, default=None) 查找key
dict.items() 以列表返回一个视图对象
dict.keys() 返回所有key
dict.values() 返回所有value
dict.update(dict2) 把字典dict2的键/值对更新到dict里
popitem() 返回并删除字典中的最后一对键和值
pop(key,default) 删除字典 key（键）所对应的值，返回被删除的值。

迭代器与生成器

迭代器

迭代器有两个基本的方法：iter() 和 next()，next()抛出异常StopIteration，作为结束信号

字符串，列表或元组对象都可用于创建迭代器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
list=[1,2,3,4]
it = iter(list)    # 创建迭代器对象
# 迭代输出
print (next(it))   # 1
print (next(it))   # 2
# 使用for循环迭代
for x in it:
    print (x, end=" ") # 1 2 3 4
# 使用while循环迭代，
while True:
	try:
		print (next(it))
    except StopIteration:
        sys.exit()

类实现迭代

在类中实现两个方法__iter__()与__next__()

__iter__()：返回一个特殊的迭代器对象（不是原来那个类，类似C++中string::iterator）， 这个迭代器对象实现了__next__()方法并通过 StopIteration 异常标识迭代的完成。

__next__()：返回下一个迭代器对象

生成器

在 Python 中，使用了 yield 的函数被称为生成器，生成器是一个返回迭代器的函数，只能用于迭代操作

在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值, 并在下一次执行 next() 方法时从当前位置继续运行。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#!/usr/bin/python3
 
import sys
 
def fibonacci(n): # 生成器函数 - 斐波那契
    a, b, counter = 0, 1, 0
    while True:
        if (counter > n): 
            return
        yield a
        a, b = b, a + b
        counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
 
while True:
    try:
        print (next(f), end=" ")
    except StopIteration:
        sys.exit()

推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。

列表(list)推导式

1
2
3
4
5
6
7
8
9
'''
[out_exp_res for out_exp in input_list]
或者 
[out_exp_res for out_exp in input_list if condition]
'''
names = ['Bob','Tom','alice','Jerry','Wendy','Smith']
new_names = [name.upper()for name in names if len(name)>3]
print(new_names)
# ['ALICE', 'JERRY', 'WENDY', 'SMITH']

字典(dict)推导式

1
2
3
4
5
6
7
8
9
'''
{ key_expr: value_expr for value in collection }
或
{ key_expr: value_expr for value in collection if condition }
'''
listdemo = ['Google','Runoob', 'Taobao']
newdict = {key:len(key) for key in listdemo}
print(newdict)
# {'Google': 6, 'Runoob': 6, 'Taobao': 6}

集合(set)推导式

1
2
3
4
5
6
7
8
'''
{ expression for item in Sequence }
或
{ expression for item in Sequence if conditional }
'''
setnew = {i**2 for i in (1,2,3)}
print(setnew)
# {1, 4, 9}

元组(tuple)推导式

1
2
3
4
5
6
7
8
'''
(expression for item in Sequence )
或
(expression for item in Sequence if conditional )
'''
a = (x for x in range(1,10)) #返回的是生成器对象
print(tuple(a))  #使用 tuple() 函数，可以直接将生成器对象转换成元组
# (1, 2, 3, 4, 5, 6, 7, 8, 9)