Python基本数据类型及基本运算_phthon基本运算

Python基本数据类型及基本运算

一、注释

单行注释：

Python中单行注释以 # 开头，例如：

# 这是一个注释
1

多行注释：

Python中多行注释用三个单引号 ''' 或者三个双引号 """ 将注释括起来，例如:

'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号 
这是多行注释，用三个单引号
'''

"""
这是多行注释，用三个双引号
这是多行注释，用三个双引号 
这是多行注释，用三个双引号
"""
1
2
3
4
5
6
7
8
9
10
11

二、基本数据类型

总结：

• Python中创建变量不需要首先定义变量类型
• 查看变量的数据类型使用函数 type(x)
• 列表、元组、集合中可以存放不同类型的元素
• Pyhton3中没有长整型，增加了复数类型 complex
  • 把形如 z = a + bj 的数称为复数，a 为实部，b 为虚部，j 为虚数单位
  • 获取实部使用函数 x.real，获取虚部使用函数 x.imag，获取对应的共轭复数使用函数 x.conjugate()

举例：

# 整数
a = 10
print(type(a))  # <class 'int'>

# 浮点数
b = 3.18
print(type(b))  # <class 'float'>

# 字符串
c = "gaoqize"
print(type(c))  # <class 'str'>

# 列表
# 可以同时包含不同的类型
d = ["1", 2.3, 3]
print(type(d))  # <class 'list'>

# 元组
e = ("python", 12, 2.3)
print(type(e))  # <class 'tuple'>

# 字典
f = {"key1":"v1", "key2":"v2"}
print(type(f))  # <class 'dict'>

# 集合
g = {"python", 12, 2.3}
print(type(g))  # <class 'set'>

# 布尔型
h = True
print(type(h))  # <class 'bool'>

# 复数
i = 1 + 2j
j = 2 + 5j
print(type(i))  # <class 'complex'>
print(i + j)  # (3+7j)
print(i - j)  # (-1-3j)
print(i * j)  # (-8+9j)
print(i.real)  # 1.0
print(i.imag)  # 2.0
print(i.conjugate())  # (1-2j)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

三、不同类型的转换

类型 (变量) 即可将变量转换成对应的类型。

字符串与整型互转

a = 10
var1 = str(a)  # 整数转换成字符串
var2 = int(var1)  # 字符串转换成整数
print(type(var1))  # <class 'str'>
print(type(var2))  # <class 'int'>

print(var1)  # 10
print(var2)  # 10
1
2
3
4
5
6
7
8

整型与浮点型互转

a = 3.18
var1 = int(a)  # 浮点数转换成整数
var2 = float(var1)  # 整数转换成浮点数
print(type(var1))  # <class 'int'>
print(type(var2))  # <class 'float'>

print(var1)  # 3
print(var2)  # 3.0
1
2
3
4
5
6
7
8

注意：

1. 浮点数转换成整数采用的是去掉小数点的方式

2. 使用 round() 函数四舍五入取对应的小数位数，如：

   var1 = round(2.366, 2)  # 对2.366采用四舍五入的方式保留2位小数
   print(var1)  # 2.37
   1
   2

列表和元组互转

d = ["1", 2.3, 3]
var1 = tuple(d)  # 列表转换成元组
var2 = list(var1)  # 元组转换成列表
print(type(var1))  # <class 'tuple'>
print(type(var2))  # <class 'list'>

print(var1)  # ('1', 2.3, 3)
print(var2)  # ['1', 2.3, 3]
1
2
3
4
5
6
7
8

嵌套元组转换成字典

e = (("name", "gaoqize"), ("sex", "man"))  # 嵌套元组，如果要转换成字典，被嵌套元组只能含有2个元素
var1 = dict(e)  # 嵌套元组转换成字典
print(type(e))  # <class 'tuple'>
print(type(var1))  # <class 'dict'>

print(e)  # (('name', 'gaoqize'), ('sex', 'man'))
print(var1)  # {'name': 'gaoqize', 'sex': 'man'}
1
2
3
4
5
6
7

不同进制互相转换

举例：

x 必须是字符串类型

其余进制想要转换成除10进制之外的进制，都必须要先转换成10进制

int("x", 2) 表示2进制的x转换成对应的10进制

bin(int("x", 8)) 表示8进制的x转换成对应的2进制

print(int("1000", 2))  # 8print(bin(int("8", 10)))  # 0b1000
1

四、对字符串的操作

Python中的字符串支持单引号、双引号、三引号（支持多行字符串）（Java只支持双引号）

定义字符串

var1 = 'str1'
var2 = "str2"
var3 = '''line1
line2'''

print(var1, var2, var3)
'''
str1 str2 line1
line2
'''
1
2
3
4
5
6
7
8
9
10

拼接字符串

使用 “+” 号进行拼接

var1 = 'str1'
var2 = "str2"

print(var1 + var2)  # str1str2
1
2
3
4

复制多个字符串

字符串 * 次数

var1 = 'str1' * 10
print(var1)  # str1str1str1str1str1str1str1str1str1str1
1
2

分割字符串split

• 默认情况下，会对空格进行分割（多个空格当作一个空格进行分割）
• 参数中指定要分割的字符

var2 = "str1 str2  str3   str4str5"
print(var2.split())  # ['str1', 'str2', 'str3', 'str4str5']
print(var2.split(' '))  # ['str1', 'str2', '', 'str3', '', '', 'str4str5']

var3 = "str1:str2:str3:str4"
print(var3.split(':'))  # ['str1', 'str2', 'str3', 'str4']
1
2
3
4
5
6

替换字符串replace

var4 = "I love Python"
print(var4.replace("Python", "Java"))  # I love Java
print(var4)  # I love Python，也就是说原字符串并没有发生改变
1
2
3

字符串大小写转换

var5 = "GAOQIZE"
print(var5.upper())  # GAOQIZE
print(var5.lower())  # gaoqize
print(var5.capitalize())  # Gaoqize，让首字母大写，其余字母小写
1
2
3
4

列表转换成字符串

使用 join 函数完成列表转换成字符串的操作，注意要声明列表中的元素通过哪个字符连接在一起

var6 = ["I", "love", "u"]

# 列表中的元素通过","进行拼接
print(",".join(var6))  # I,love,u
1
2
3
4

五、对列表的操作

• 拼接列表和复制多个列表的具体操作与字符串一致。
• 列表也可以嵌套，如 list1 = ["hello", 12, 12.8, ["hi", 22]]

通过索引访问列表元素

类似数组，直接使用索引即可访问对应的元素。

从前向后访问索引位置从0开始，从后往前访问索引位置从-1开始。

list1 = ["hello", 12, 12.8, ["hi", 22]]
print(list1[0])  # hello
print(list1[-1])  # ['hi', 22]
1
2
3

通过分片访问列表元素

索引的位置使用 [x:y] 的格式，注意是左闭右开。

[x:] 表示x位置之后的所有元素（包括x），[:y] 表示y位置之前的所有元素（不包括y）。

list1 = ["hello", 12, 12.8, ["hi", 22]]
print(list1[0:2])  # ['hello', 12]
print(list1[-3:-1])  # [12, 12.8]
print(list1[0:])  # ['hello', 12, 12.8, ['hi', 22]]
print(list1[:3])  # ['hello', 12, 12.8]
1
2
3
4
5

等步长访问列表元素

使用 [::x] 表示先访问第一个元素，然后依次访问下一个步长为x的元素。

list1 = ["hello", 12, 12.8, ["hi", 22]]
print(list1[::3])  # ['hello', ['hi', 22]]
print(list1[::1])  # ['hello', 12, 12.8, ['hi', 22]]
print(list1[::2])  # ['hello', 12.8]
1
2
3
4

增加列表元素

使用 append() 向列表尾部添加单个元素。

list1 = ["hello"]
list1.append("你好")
print(list1)  # ['hello', '你好']
1
2
3

使用 extend() 向列表尾部添加一个列表。

list1 = ["hello", 12, 12.8]
list2 = ["more"]
list1.extend(list2)
print(list1)  # ['hello', 12, 12.8, 'more']
1
2
3
4

注意：使用 append() 添加元素会创建一个新的列表，使用 extend() 添加元素是在原列表的基础上添加。

使用 insert() 向列表指定位置添加一个元素。

list1 = ["hello", 12, 12.8]
list1.insert(0, "first")  # 在0位置插入一个元素
print(list1)  # ['first', 'hello', 12, 12.8]
1
2
3

删除列表中的元素

使用del list[x] 删除索引位置为x的元素。

list1 = ["hello", 12, 12.8]
del list1[0]
print(list1)  # [12, 12.8]
1
2
3

使用 pop() 弹出列表的最后一个元素。

list1 = ["hello", 12, 12.8]
print(list1.pop())  # 12.8
1
2

统计列表中某个元素出现的次数

使用 count() 得到某个元素出现的次数。

list1 = ["hello", 12, 12.8, 12]
print(list1.count(12))  # 2
1
2

六、对元组的操作

元组和列表最大的不同是：元组一旦创建，里面的元素不可变更。一旦发生变更，就会创建一个新的元组。

其余操作和列表几乎一致。

七、对字典的操作

合并多个字典

使用 update 完成对字典的合并或更新：相同的key进行更新，不同的key进行合并。

dict1 = {"k1":"v1", "k2":"v2"}
dict2 = {"k1":"update_k1", "k3":"v3"}
dict1.update(dict2)
print(dict1)  # {'k1': 'update_k1', 'k2': 'v2', 'k3': 'v3'}
1
2
3
4

通过key获得对应的value

使用 字典名[“key”] 获得该字典中对应key的value值。

dict1 = {"k1":"v1", "k2":"v2"}
print(dict1["k1"])  # v1
1
2

增加一个新的键值对

使用 字典名[“key”] = “value” 向该字典中增加一个新的键值对。（如果该key已经存在，则更新该key的值）

dict1 = {"k1":"v1", "k2":"v2"}
dict1["k3"] = "v3"
print(dict1)  # {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
1
2
3

八、对集合的操作

集合中的元素是不可重复的。

创建空的集合：

var1 = {}  # 一对大括号创建一个空的字典
var2 = set()  # 固定格式创建空的集合
print(type(var1))  # <class 'dict'>
print(type(var2))  # <class 'set'>
1
2
3
4

并集

var1 = {"gao", 12, 3.16}
var2 = {"new", "gao"}
print(var1.union(var2))  # {3.16, 'new', 'gao', 12}
# 会自动去掉重复的元素
1
2
3
4

交集

var1 = {"gao", 12, 3.16}
var2 = {"new", "gao"}
print(var1.intersection(var2))  # {'gao'}
1
2
3

差集

var1 = {"gao", 12, 3.16}
var2 = {"new", "gao"}
print(var1.difference(var2))  # {3.16, 12}
1
2
3

是否是子集

var1 = {"gao", 12, 3.16}
var2 = {"gao"}
print(var2.issubset(var1))  # True
1
2
3

九、基本运算符

整数和浮点数做运算，结果是浮点数。