x进制类型
定义
- \(0b****\)：用二进制定义整型
- \(0o****\)：用八进制定义整型
- \(0x****\)：用十六进制定义整型
a = 0b1111
b = 15
c = 0o17
d = 0x0F
输出：
转换
- \(bin()\)：二进制转换
- \(oct()\)：八进制转换
- \(hex()\)：十六进制转换
注意：返回类型是\(str\)类型
- \(int(a,base=b)\)：x进制转整型
a = 13
b = bin(a)
c = oct(a)
d = hex(a)
e = int(b,base=2)
f = int(c,base=8)
g = int(d,base=16)
输出：
变量
使用 \(type()\) 检查变量的类型。
使用Python中内置的函数对变量类型进行转换。
int()：将一个数值或字符串转换成整数，可以指定进制。float()：将一个字符串转换成浮点数。str()：将指定的对象转换成字符串形式，可以指定编码。chr()：将整数转换成该编码对应的字符串（一个字符）。ord()：将字符串（一个字符）转换成对应的编码（整数）。
例：
a = '97'
b = int(a)
c = float(b)
d = chr(b)
e = ord('a')
输出结果：
字符串内容格式化
占位符
| 占位符 | 说明 |
|---|---|
%C |
格式化字符及其ASCII码 |
%s |
格式化字符串 |
%d |
格式化整数 |
%u |
格式化无符号整型 |
%o |
格式化无符号八进制数 |
%x |
格式化无符号十六进制数 |
%X |
格式化无符号十六进制数(大写) |
%f |
格式化浮点数字，可指定小数点后的精度 |
%e |
用科学计数法格式化浮点数 |
%E |
作用同%e，用科学计数法格式化浮点数 |
%g |
%f和%e的简写 |
%G |
%F和%E的简写 |
%p |
用十六进制数格式化变量的地址 |
格式化方法一——%
a = '这是一个整数n=%d' % 5
输出：
格式化方法二——format()
b = '这是一个整数n={n}'.format(n=5)
格式化方法三
c = f'这是一个整数n={5:d}'
输出：
练习
华氏温度转换为摄氏温度
提示：华氏温度到摄氏温度的转换公式为：\(C=(F - 32) \div 1.8\)。
答案：
f = float(input('请输入华氏温度: '))
c = (f - 32) / 1.8
print('%.1f华氏度 = %.1f摄氏度' % (f, c))
字符串
使用字符串
s1 = 'hello, world!'
s2 = "hello, world!"
# 以三个双引号或单引号开头的字符串可以折行
s3 = """
hello,
world!
"""
输出：
在
\后面可以跟一个八进制或者十六进制数来表示字符，例如\141和\x61都代表小写字母a，前者是八进制的表示法，后者是十六进制的表示法。也可以在\后面跟Unicode字符编码来表示字符
s1 = '\141\142\143\x61\x62\x63'
s2 = '\u6253\u4e0d\u6b7b\u7684\u5c0f\u5f3a'
输出：
Python为字符串类型提供了非常丰富的运算符，我们可以使用
+运算符来实现字符串的拼接，可以使用*运算符来重复一个字符串的内容，可以使用in和not in来判断一个字符串是否包含另外一个字符串（成员运算），我们也可以用[]和[:]运算符从字符串取出某个字符或某些字符（切片运算）
s1 = 'hello ' * 3
s2 = 'world'
s1 += s2
b1 = 'll' in s1
b2 = 'good' in s1
str1 = 'abc123456'
# 从字符串中取出指定位置的字符(下标运算)
s3 = str1[2]
# 字符串切片(从指定的开始索引到指定的结束索引)
str2 = str1[2:5]
str3 = str1[2:]
str4 = str1[2::2]
str5 = str1[::-1]
str6 = str1[-3:-1]
输出：
字符串操作内置方法
str1 = 'hello, world!'
# 通过内置函数len计算字符串的长度
print(len(str1)) # 13
# 获得字符串首字母大写的拷贝
print(str1.capitalize()) # Hello, world!
# 获得字符串每个单词首字母大写的拷贝
print(str1.title()) # Hello, World!
# 获得字符串变大写后的拷贝
print(str1.upper()) # HELLO, WORLD!
# 从字符串中查找子串所在位置
print(str1.find('or')) # 8
print(str1.find('shit')) # -1
# 与find类似但找不到子串时会引发异常
# print(str1.index('or'))
# print(str1.index('shit'))
# 检查字符串是否以指定的字符串开头
print(str1.startswith('He')) # False
print(str1.startswith('hel')) # True
# 检查字符串是否以指定的字符串结尾
print(str1.endswith('!')) # True
# 将字符串以指定的宽度居中并在两侧填充指定的字符
print(str1.center(50, '*'))
# ******************hello, world!*******************
# 将字符串以指定的宽度靠右放置左侧填充指定的字符
print(str1.rjust(50, ' '))
# hello, world!
str2 = 'abc123456'
# 检查字符串是否由数字构成
print(str2.isdigit()) # False
# 检查字符串是否以字母构成
print(str2.isalpha()) # False
# 检查字符串是否以数字和字母构成
print(str2.isalnum()) # True
str3 = ' [email protected] '
print(str3)
# [email protected]
# 获得字符串修剪左右两侧空格之后的拷贝
print(str3.strip())
# [email protected]
列表
使用列表
定义
list1 = [1, 3, 5, 7, 100]
print(list1) # [1, 3, 5, 7, 100]
# 乘号表示列表元素的重复
list2 = ['hello'] * 3
print(list2) # ['hello', 'hello', 'hello']
索引
print(list1[0]) # 1
print(list1[4]) # 100
# print(list1[5]) # IndexError: list index out of range
print(list1[-1]) # 100
print(list1[-3]) # 5
修改列表
list1 = [1, 3, 5, 7, 100]
# 添加元素
list1.append(200)
list1.insert(1, 400)
# 合并两个列表
# list1.extend([1000, 2000])
list1 += [1000, 2000]
print(list1) # [1, 400, 3, 5, 7, 100, 200, 1000, 2000]
print(len(list1)) # 9
# 先通过成员运算判断元素是否在列表中，如果存在就删除该元素
if 3 in list1:
list1.remove(3)
if 1234 in list1:
list1.remove(1234)
print(list1) # [1, 400, 5, 7, 100, 200, 1000, 2000]
# 从指定的位置删除元素
list1.pop(0)
list1.pop(len(list1) - 1)
print(list1) # [400, 5, 7, 100, 200, 1000]
# 清空列表元素
list1.clear()
print(list1) # []
遍历
# 通过循环用下标遍历列表元素
for index in range(len(list1)):
print(list1[index])
# 通过for循环遍历列表元素
for elem in list1:
print(elem)
# 通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值
for index, elem in enumerate(list1):
print(index, elem)
切片操作
fruits = ['grape', 'apple', 'strawberry', 'waxberry']
fruits += ['pitaya', 'pear', 'mango']
# 列表切片
fruits2 = fruits[1:4]
print(fruits2) # apple strawberry waxberry
# 可以通过完整切片操作来复制列表
fruits3 = fruits[:]
print(fruits3) # ['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
fruits4 = fruits[-3:-1]
print(fruits4) # ['pitaya', 'pear']
# 可以通过反向切片操作来获得倒转后的列表的拷贝
fruits5 = fruits[::-1]
print(fruits5) # ['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']
列表排序
list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
list2 = sorted(list1)
# 函数的设计就应该像sorted函数一样尽可能不产生副作用
list3 = sorted(list1, reverse=True)
# 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
list4 = sorted(list1, key=len)
# 给列表对象发出排序消息直接在列表对象上进行排序
list1.sort(reverse=True)
print(list1)
# ['zoo', 'orange', 'internationalization', 'blueberry', 'apple']
sorted函数返回列表排序后的拷贝不会修改传入的列表
输出：
sorted(list[, key][, reverse])方法key：指定一个参数的函数，用于从每个列表元素中提取比较键：
key=str.lower。默认值为None（直接比较元素）。reverse ：是一个布尔值。如果设置为
True，那么列表元素将按照每个比较反转进行排序。
生成式与生成器
生成式
# 不使用生成式
L1 = []
for x in range(1,11):
L1.append(x)
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 使用生成式
L2 = [ i for i in range(1,11) ]
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
集合、字典的生成式方法都只是括号的不同，使用方法一样。
需要注意的是元组的生成式方法：
a *=* (x *for* x *in* range(1,10)) print(a) # <generator object <genexpr> at 0x0000025AE05C8D48>返回的是一个生成器对象，需要转换一下
print(tuple(a)) # (1, 2, 3, 4, 5, 6, 7, 8, 9)
生成器
生成式是一次性将符合判断条件的所有元素输出至列表；而生成器则是根据需求，在调用时再推算后续的元素，不必创建完整的List,节省大量的空间。 而生成器(generator)的名称也是由其 一边循环一边计算的机制得来的。
可以通过next()函数来取得generator中的下一个返回值
g = (i for i in range(10))
print(type(g))
print(next(g))
print(next(g))
print(next(g))
# <class 'generator'>
# 0
# 1
# 2
元组
Python中的元组与列表类似也是一种容器数据类型，可以用一个变量（对象）来存储多个数据，不同之处在于元组的元素不能修改。
# 定义元组
t = ('字符串', 38, 38.1,True)
print(t) # ('字符串', 38, 38.1, True)
# 获取元组中的元素
print(t[0]) # 字符串
print(t[3]) # True
# 遍历元组中的值
for member in t:
print(member)
# 字符串
# 38
# 38.1
# True
# 重新给元组赋值
t[0] = '王大锤' # TypeError
# 变量t重新引用了新的元组原来的元组将被垃圾回收
t = ('王大锤', 20, True, '云南昆明')
print(t) # ('王大锤', 20, True, '云南昆明')
# 将元组转换成列表
person = list(t)
print(person) # ['王大锤', 20, True, '云南昆明']
# 列表是可以修改它的元素的
person[0] = '李小龙'
person[1] = 25
print(person) # ['李小龙', 25, True, '云南昆明']
# 将列表转换成元组
fruits_list = ['apple', 'banana', 'orange']
fruits_tuple = tuple(fruits_list)
print(fruits_tuple) # ('apple', 'banana', 'orange')
这里有一个非常值得探讨的问题，我们已经有了列表这种数据结构，为什么还需要元组这样的类型呢？
- 元组中的元素是无法修改的，事实上我们在项目中尤其是多线程环境（后面会讲到）中可能更喜欢使用的是那些不变对象（一方面因为对象状态不能修改，所以可以避免由此引起的不必要的程序错误，简单的说就是一个不变的对象要比可变的对象更加容易维护；另一方面因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，这样就可以省掉处理同步化的开销。一个不变对象可以方便的被共享访问）。所以结论就是：如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。
- 元组在创建时间和占用的空间上面都优于列表。我们可以使用
sys模块的getsizeof函数来检查存储同样的元素的元组和列表各自占用了多少内存空间。
import sys
print(sys.getsizeof([1,2,3,4,5])) #104
print(sys.getsizeof((1,2,3,4,5))) #88
集合
创建
# 创建集合的字面量语法
set1 = {1, 2, 3, 3, 3, 2}
print(set1) # {1, 2, 3}
print('Length =', len(set1)) # Length = 3
# 创建集合的构造器语法(面向对象部分会进行详细讲解)
set2 = set(range(1, 10))
set3 = set((1, 2, 3, 3, 2, 1))
print(set2, set3) # {1, 2, 3, 4, 5, 6, 7, 8, 9} {1, 2, 3}
# 创建集合的推导式语法(推导式也可以用于推导集合)
set4 = {num for num in range(1, 20) if num % 3 == 0 or num % 5 == 0}
print(set4) # {3, 5, 6, 9, 10, 12, 15, 18}
添加和删除
set1.add(4) # 添加元素
set1.add(5)
set2.update([11, 12]) # 合并元素
set2.discard(5) # 删除元素
if 4 in set2:
set2.remove(4) # 删除元素
print(set1, set2)# {1, 2, 3, 4, 5} {1, 2, 3, 6, 7, 8, 9, 11, 12}
print(set3.pop())# 1 # 随机删除元素
print(set3) # {2, 3}
网上资料查询
pop()是随机删除一个元素，但运行后删除的删除的最左侧的元素
集合运算
# 集合的交集、并集、差集、对称差运算
print(set1 & set2) # {1, 2, 3}
# print(set1.intersection(set2))
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
# print(set1.union(set2))
print(set1 - set2) # set()
# print(set1.difference(set2))
print(set1 ^ set2) # {4, 5, 6, 7, 8, 9}
# print(set1.symmetric_difference(set2))
# 判断子集和超集
print(set2 <= set1) # False
# print(set2.issubset(set1))
print(set3 <= set1) # True
# print(set3.issubset(set1))
print(set1 >= set2) # False
# print(set1.issuperset(set2))
print(set1 >= set3) # True
# print(set1.issuperset(set3))