Python学习笔记（二）基本数据类型

“Life is short, You need Python” – Bruce Eckel

Environment

• OS: macOS Mojave
• Python version: 3.7
• IDE: Jupyter Notebook

0. 写在前面

Python 中的数据类型可分为基本数据类型和组合数据类型，基本数据类型包括整型、浮点型、复数类型、字符串、布尔类型，组合数据类型包括列表、元组、字典、集合，其中还有更细的分类，如整型包括不同进制，字典包括有序和无序等。这里做一点儿个人的Python学习笔记，本文内容包括获取和转换类型、基础数据类型的常用操作，有较多的字符串的常用方法。

Python 作为动态类型语言，在编写代码时不用声明变量的数据类型。

1. 类型获取和转换

1.1 获取

• type(obj)函数

word = 'word'
print(type(word)) # str，字符串类型

integer = 1
print(type(integer)) # int，整型

number = 6.
print(type(number)) # float，浮点型

complex_num = 1 + 2j
print(type(complex_num)) # complex，复数

• isinstance(obj, class_or_tuple)函数，若传入的对象是预判类型或其子类型，则返回 True，否则返回 False

print(isinstance(word, str)) # True
print(isinstance(1, str)) # False
print(isinstance(word, object)) # True

1.2 转换

• str() 函数，传入一个整型或浮点型对象，返回一个字符串对象

print(str(123)) # '123'

• int() 函数

例

# 传入浮点型对象，实例化生成一个整型对象。截断而非四舍五入
print(int(6.66)) # 6
# 传入字符串对象，实例化生成一个整型对象
print(int('6')) # 6

• float() 函数

# 传入一个整型对象，实例化生成一个浮点型对象
print(float(6)) # 6.0
# 传入一个包含小数点的字符串对象，实例化生成一个浮点型对象
print(float('6.')) # 6.0

# 科学计数法
x = '1e6' # 表示 1 x 10^6
print(float(x)) # 1000000.0

• eval()函数，传入一个字符串表达式，返回表达式的值

print(eval('6')) # 6
print(eval('6.')) # 6.0
print(eval('6 ** 2')) # 36

2. 数字类型

包括整型、浮点型和复数类型。

2.1 整型

Python3 中的整型已包含了长整型。

整型默认为十进制，还包括二进制（以0b打头）、八进制（以0o打头）和十六进制（以0x打头）

8 == 0b1000 == 0o10 == 0x8 # True

• bin(number)函数、oct(number)函数、hex(number)函数分别将十进制转换为二进制、八进制、十六进制

dec2bin = bin(8) 
dec2oct = oct(8)
dec2hex = hex(8)
print(dec2bin, dec2oct, dec2hex)
# 0b1000 0o10 0x8

注意，使用 bin、oct、hex 转换后，返回结果为字符串类型

print(type(dec2bin)) # 'str'

• int()函数可以将其他进制（字符串类型）转为十进制，需要指定传入数字的进制

bin2dec = int('0b1000', 2)
oct2dec = int('0o10', 8)
hex2dec = int('0x8', 16)
print(bin2dec, oct2dec, hex2dec)
# 8 8 8

2.2 浮点型

因为计算机采用二进制小数来表示浮点数的小数部分，浮点型需要关注浮点数问题，如下

res = 0.1 + 0.2
print(res) # 0.30000000000000004

记得不要企图使用 == 对两个浮点数进行比较。

• 若要获得精确的数可以考虑使用 round(number, ndigits=None) 函数实现四舍五入

res = 0.1 + 0.2
print(round(res, 1)) # 0.3

2.3 复数

复数表示为 a + bj 或 a + bJ，j大小写都一样，a为实部，b为虚部。注意，当虚部为 1 时需要显式地写出。

complex_number = complex('1+j')
print(complex_number) # (1+1j)

2.4 运算操作

2.4.1 运算操作符

注意操作符的优先级。

加减乘除 + - * /

1 + 2 # 3
0.1 + 0.2 # 0.30000000000000004

取反 -

1 + -2 # -1

乘方 **

1 + 2**-2 # 1.25

整数商 // 和模运算 %

print(6 // 4) # 1
print(6 % 4) # 2

注意

• 整数与浮点数的运算结果为浮点数
• 除法运算的结果永远为浮点数

2.4.2 运算操作函数

除 Python 的自带函数和 math 库外，更关键是Numpy、SciPy的使用（后面写上再链接起来）。

• abs(x) 绝对值

abs(-3) # 3

• pow(x, y, z=None) 幂次方

res = pow(2, 5, 3) # 较 2**5 % 3 更快
print(res) # 2

• round(number, ndigits=None) 四舍五入

# 位数不足，无补齐
res = round(.618, 5)
print(res) # 0.168

• divmod(x, y) 整数商和模运算

res = divmod(11, 3) # 等价于返回 (x // y, x % y)，但运算更快
print(res) # (3, 2)

• 序列最值 max 和 min，传入的可以是一组数或者一个序列类型

max_res = max(9, 5, 2, 7)
min_res = min(9, 5, 2, 7)
print(max_res, min_res) # 9 2
# 还可以
arr = [9, 5, 2, 7]
print(max(arr), min(arr)) # 9 2

• sum 求和，传入的必须为序列类型

res = sum([0, 1, 2, 3, 4])
print(res) # 10

3. 布尔类型

True 的值为 1，False 为 0

print(True + True) # 2
print(True + False) # 1
print(True * False) # 0
print(True / False) # 报错

• any(iterable) 和 all(iterable)

print(any([True, False])) # True
print(all([False, True])) # False

3.1 用法

• 表示逻辑运算的结果

print(1 == 2) # False
print(10 > 9) # True

• 作判断条件

i = 0
judge = True
total = 0
while judge:
    total += i
    i += 1
    judge = i < 5
    
print(total) # 10
print(judge) # False

• 作掩码

import numpy as np

arr = np.array([9, 5, 2, 7])
mask = arr > 6
print(mask) # [True, False, False, True]
print(arr[mask]) # [9, 7]

4 字符串

• 字符串类型又称“文本类型”
• Python 舍弃了“字符”变量，仅留下了“字符串”变量
• 用成对出现的双引号或单引号括起来表示

print("Hello, Python")
print('Hello, Python')
# 字符串本身包括了单（双）引号，可以考虑用双（单）引号
print("I'm a string.")
# 字符串即有单引号又有双引号，使用转义字符
print("My name is \"Python\".")
# 字符串对象前面加r，表示“原始字符串”，其中转义字符被沉默
# 但“原始字符串”不允许以 \ 结尾
file_name = r"/Users/xxx/data/test.ipynb"
print(file_name)
# 成对的连续三个双引号或单引号可表示一个跨多行的字符串
long_string = '''
This is
a string
going through 
multiple lines.
'''

• 每个单一字符对应唯一的二进制编码
• Python 中使用的是 Unicode 编码

将中文字库、英文字母、数字、特殊字符等转换为计算机可识别的二进制数

ord 函数将字符转换为 Unicode 码

print(ord('1')) # 49
print(ord('$')) # 36
print(ord('六')) # 20845

chr将 Unicode 码转换为字符

print(chr(49)) # 1
print(chr(36)) # $
print(chr(20845)) # 六

4.1 访问

• 变量名[index] 索引，index 必须小于字符串的长度

string = "My name is Python."
print(1) # 正向索引，输出 y
print(-1) # 反向索引，输出 .

• 变量名[start: end: step]，切片范围[string[start], string[end])，即不包括 end 索引，step 默认为 1。

string = '0123456789'
print(string[:5:2]) # 024
print(string[-1:-5]) # 输出为空
print(string[::-1]) # 逆序输出

4.2 修改

无法通过索引修改其中字符内容

string = '0123456789'
string[1] = 9 # 报错

4.3 常用操作符

• 字符串1 + 字符串2 ，拼接

print('abc' + '123') # abc123

• n * 字符串 或 字符串 * n ，重复

print('abc' * 3) # abcabcabc

• 子集 in 全集 ，成员资格符

name = 'Chunk Forker'
print('For' in name) # True
print('for' in name) # False

• 比较操作符，先比较第一个字符的ASCII码，若相同，则比较下一个字符，一直到最后一个字符

str1 = 'abc'
str2 = 'abd'
print(str1 < str2) # True
print(str1 > str2) # False

4.4 常用方法

• 格式化输出，通过 format 方法

"string{0:格式}string{1:格式}".format(val0, val1)

golden_section = 0.6180339887
euler_constant = 0.5772156649

print("golden section = {}, euler_constant = {}".format(golden_section, euler_constant))
print("euler_constant = {1}, golden section = {0}".format(golden_section, euler_constant))

# 格式化输出
## 数字千位逗号分隔符
print("{0:,}".format(13579)) # 13,579

## : 后跟需要的格式，_ 表示使用下划线填充，
## ^ 表示居中，20 表示输出的宽度为20
print("{0:_^15}".format(golden_section))
## * 表示使用星号填充，< 表示输出的内容左对齐
print("{0:*<20}".format(euler_constant))

## 综合上面两者，注意修饰符号的顺序
print("{0:_>10,}".format(13579)) # ____13,579

整数的进制转换输出

# 十进制以十进制二进制、八进制、十六进制和Unicode码输出
print("dec {0:d}, bin {0:b}, oct {0:o}, hex {0:x}, Unicode {0:c}".format(450))

浮点数转换为字符串输出

golden_section = 0.6180339887

# 保留两位小数
print("{0:.2f}".format(golden_section)) # 0.62

# 按百分数输出
print("{0:.1%}".format(golden_section)) # 61.8%

# 科学计数法输出
print("{0:.2e}".format(golden_section)) # 6.18e-01

注意严格的符号顺序，不可颠倒

1. : 引导符号，表示格式化的开始
2. 填充符号，如 _ 或 * 等
3. 对齐符号，< 左对齐，> 右对齐，^ 居中
4. 指定宽度
5. 输出数字千分位逗号分隔符，适用于整数和浮点数
6. 指定精度，在 . 后面加上需要的精度，对于浮点数表示保留几位小数，对于字符串表示输出字符串的最大长度
7. 指定类型，整数类型包括d, b, o, x, c, X，浮点类型包括e, E, f, %

• 查找计数

str.count(sub[, start[, end]]) 计数

string = 'This is Python.'
string.count('i', 5) # 1

str.index(sub[, start[, end]]) 和 str.rindex(sub[, start[, end]]) 分别从头和从尾开始查找子字符串 sub ，返回第一次出现位置的索引（未找到则报错）

string = 'This is Python.'
print(string.index('hi')) # 1
print(string.index('hello')) # 报错

str.find(sub[, start[, end]]) 和 str.rfind(sub[, start[, end]]) 查找子字符串 sub 第一次出现位置的索引（不在则返回-1，与index方法区别仅此）

string = 'This is Python.'
print(string.find('hi')) # 1
print(string.find('hello')) # -1

• 拆分聚合

str.partition(sub) 与 str.rpartition：找到子字符串 sub，以sub字符串分开，即 (pre_sub, sub, post_sub)，返回一个元组

string = 'This is Python.'
print(string.partition('is')) # ('Th', 'is', ' is Python.')

str.split(sep=None, maxsplit=-1) ，以sep（默认为空格）为分隔符切片string字符串（作为sep的字符/字符串会没掉），返回一个子字符串的列表

string = 'This is Python.'
print(string.split('is')) # ['Th', ' ', ' Python.']

str.splitlines(keepends=False) ，以’\n’和’\r’为分隔符，返回一个以各行字符串作为元素的列表，keepends默认为False，如指定 keepends=True，则保留’\n’或’\r’

# str对象以'\n'开头时，返回列表第一个为空元素；string 以'\n结尾时，最后并不会有空元素
string = "\n Life is short  \r  You need Python\n"
print(string.splitlines())

str.join(iterable) 返回一个字符串，其以 str 对象作为分隔符，插入到传入的可迭代对象元素之间，传入的可以时字符串或以字符串为元素的可迭代对象

chrs = ['abc', 'def', 'ghi']
print('^.^'.join(chrs)) # abc^.^def^.^ghi

• 内容判断

str.endswith(sub[, start[, end]]) 与 str.startswith：判断string是否以sub字符串结尾 / 开头。常用于判断文件类型，如 filename.endswith('.jpg)'

file_list = ['README.md', 'table.csv', 'image.jpg', 'graph.jpg']
image_files = []
for file_name in file_list:
    if file_name.endswith('.jpg'):
        image_files.append(file_name)
        
print(image_files) # ['image.jpg', 'graph.jpg']

str.isdigit()检查字符串是否只由数字组成

print('123'.isdigit()) # True
print('abc123'.isdigit()) # False

str.isalpha()检查字符串是否只由字符组成

print('abc'.isalpha()) # True
print('abc123'.isalpha()) # False

str.isalnum() 判断字符串是否只由字符和数字组成

print('abc123'.isalnum()) # True
print('abc_123'.isalnum()) # False

• 大小写判断

str.islower() 判断是否所有字符都是小写，为真返回 Ture，否则返回 False

str.isupper() 判断是否所有字符都是大写，为真返回 Ture，否则返回 False

str.istitle() 判断是否所有单词都是仅首字母大写，为真返回 Ture，否则返回 False

str.isspace() 判断是否所有字符都是空白字符，为真返回 Ture，否则返回 False

• 大小写转换

str.capitalize() 返回一个字符串，其为string字符串第一个字符为大写

str.title() 返回一个字符串，其为string字符串中各单词第一个字母大写
str.upper() ，str.lower() ，str.title() 分别为将字符全部转换为大写、全部转换为小写、首字符转换为大写余为小写

lower2upper = 'china'.upper()
print(lower2upper) # 'CHINA'
upper2lower = 'CHINA'.lower()
print(upper2lower) # 'china'
lower2title = 'china'.title()
print(lower2title) # 'China'

str.swapcase() 返回一个字符串，其为string字符串中大写变小写，小写变大写

str.casefold() 返回一个字符串，其为string字符串全小写（比lower更强，对unicode都有效

• 位置设置

str.center(width) 返回一个字符串，其居中，并用空格填充至长度为width

str.ljust(width) 返回一个字符串，其左对齐，并用空格填充至长度为width

str.rjust(width) 返回一个字符串，其右对齐，并用空格填充至长度为width

• 删除空格

str.strip(chars=None) ，str.lstrip(chars=None) ，str.rstrip(chars=None) 分别删除字符串左右两边、左边、右边的指定字符，默认为删除空格

word = '__comfortable__'
print(word.strip('_')) # comfortable
print(word.lstrip('_')) # comfortable__
print(word.rstrip('_')) # __comfortable

• 内容替换

str.replace(old, new, count=-1) 替换

word = 'f  k'
print(word.replace(' ', 'x')) # fxxk
print(word.replace(' ', 'x', 1)) # fx k

str.translate(table) ，返回一个字符串，根据table的规则（可以由str.maketrans(‘a’, ‘b’)定制）转换原字符串中的字符（串）

string = "I like the house"
print(string.translate(string.maketrans('ou', 'or'))) # I like the horse

str.expandtabs(tabsize=8) ，返回一个字符串，将原字符串中的tab符号（’\t’）转换为空格，如不指定参数，默认的空格数为 8

string = 'This\tis\tPython.'
string.expandtabs()
print(string) # This	is	Python.