Python基础2——基本数据类型
1.赋值
1.Python中变量不需要声明，每个变量在使用前必须赋值，变量赋值以后该变量才会被创建。
2.在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型
3.等号（=）用来给变量赋值，等号运算符左边是一个变量名，等号运算符右边是存储在变量中的值。
4.多个变量赋值（不建议使用）：
# 多个变量赋值
#多个变量赋予一个值
a = b = c = 1
#多个变量赋予多个值
a, b, c = "abc", 1, 1
2.标准数据类型
Python中有六个标准数据类型：
不可变数据：Number（数字）、String（字符串）、Tuple（元组）
可变数据：List（列表）、Dictionary（字典）、Set（集合）
3.Number（数字）
Python3支持int、float、bool、complex（复数）,可以使用内置的type函数来查询所指的数据类型。
a, b, c, d = 1, 1.25, True, "String"
print(type(a), type(b), type(c), type(d)
Python3中，把True和False定义成关键字了，但他们的值还是1和0，仍然可以和数字相加。（注意这里的True和False是大写）
1.del函数删除对象引用
del语句的语法是del var1[,var2[,var3[....,varN]]]
可以使用del语句删除单个或者多个对象
del var
del var_a, var_b
2.数值运算
# 数值运算
a = 4
b = 2
# 加
print(a+b)
# 减
print(a-b)
# 乘
print(a*b)
# 除
# / 返回一个浮点数
print(a/b)
# // 返回一个整数
print(a//b)
# 取余
print(a % b)
# 乘方
print(a ** b)
注意事项：
1.一个变量可以通过赋不同的值指向不同类型的对象。
2.数值的除法包含两个运算符：/ 返回一个浮点数， //返回一个整数。
3.在混合计算时，Python会把整型转换成为浮点数。
4.Python还支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型
4.String（字符串）
1.可以使用单引号、双引号和三引号来表示字符串
2.单引号双引号的使用完全相同，三引号可以指定一个多行字符串
3.反斜杠+某些特殊字符可以转义某些字符
4.字符串前加r或者R，输出源字符串
5.+运算时连接，*字符串是重复，两个字符串不能进行重复运算
6.字符串的截取语法格式：变量[头下标:尾下标:步长]
7.Python中的字符串有两种索引方式，从左向右从0开始，从右向左以-1开始。
8.Python中没有单独的字符串类型（没有char类型），一个字符就是长度为1的字符串
# 字符串
# 原始字符串
str1 = '123456789'
# 输出原始字符串
print("输出原始字符串"+str1)
# 输出字符串的第一个字符
print("输出字符串的第一个字符"+str1[0])
# 输出字符串从第一个到倒数第一个之间的所有字符（包含第一个但不包含最后一个）
print("输出字符串从第一个到倒数第二个之间的所有字符"+str1[0:-1])
# 输出第二个字符之后的所有字符
print("输出第二个字符之后的所有字符"+str1[2:])
# 从第二个字符开始输出到第五个字符输出规则为步长是2
print("从第二个字符开始输出从第二个字符开始到第五个字符之间步长为2字符"+str1[2:6:2])
# 输出两遍字符串
print("输出两遍字符串"+str1)
# 连接字符串
print("连接字符串"+str1+"abc")
print("---------------------------------")
# 使用反斜杠转义特殊字符
x = 'I am Liming
I am from China'
print(x)
# 在字符串前面加一个r，表示输出原始字符
print(r"I am Liming
I am from China")
5.List（列表）
1.List（列表）是Python中使用最频繁的数据类型。
2.列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
3.列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
4.和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
5.列表截取语法：变量[头下标:尾下标：步长]。
6.列表有两种索引方式，索引值从左向右以0开始，从右向左以-1开始。
7.加号 + 是列表连接运算符，星号 * 是重复操作。
# 列表
listA = ['abc', 123, True, complex(1.2, 2.1), 'def', 456, False, complex(2, 3), [1, 2]]
# 输出列表
print("输出列表", end='')
print(listA)
# 截取前五个元素组成新的列表
listB = listA[0:5]
print("截取前五个元素组成新的列表", listB)
# 截取后五个元素组成新的列表
# 截取不包括尾下标元素
listB = listA[-5:]
print("截取后五个元素组成新的列表", listB)
# 步长为2，遍历列表
listB=listA[0::2]
print(listB)
# 相对于字符串，列表是可变的
listA[4] = 'abc'
print(listA)
# 列表重复
print(listA*2)
# 列表连接
print(listA+listA)
注意：
1.list列表截取语法会取头下标的值，但不会尾下坐标的值，而且无论什么时候，头下标的值都是小于尾下标的。（示例看Python常见错误）
2.嵌套列表中取出一个列表得到的不是循环列表，而是一个
3.列表中的元素可以改变的
4.翻转字符串
# 字符串
listA = ['abc', 123, True, complex(1.2, 2.1), 'def', 456, False, complex(2, 3), [1, 2]]
# 翻转字符串
listB=listA[-1::-1]
print(listB)
listB=listA[-1::-1]
第一个参数 -1 表示最后一个元素，第二个参数为空，表示移动到列表末尾，第三个参数为步长，-1 表示逆向
6.Tuple（元组）
元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。元组中的元素的数据类型也可以不相同。
# 元组
tupleA = ('abc', 123, True, complex(1.2, 2.1), 'def', 456, False, complex(2, 3), [1, 2])
# 输出元组
print(tupleA)
# 输出元组前五个元素
print(tupleA[0:5])
# 输出元组后五个元素
print(tupleA[-5:])
# 连接元组
print(tupleA+tupleA)
# 重复元组
print(tupleA*2)
注意：
1.虽然tuple（元组）的元素不能改变，但是它可以包含可变的对象，比如list列表。
2.构造包含0个或1个元素的元组比较特殊，所以有一些额外的语法规则：
tup1 = () # 空元组
tup2 = (20,) # 一个元素，需要在元素后添加逗号
3.String、List、Tuple都属于Sequence（序列）
4.连接、重复、遍历、切分操作和列表操作跟列表一样。
7.Set（集合）
1.集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
2.集合的基本功能是进行成员关系测试和删除重复元素。
3.可以使用大括号 { } 或者 set() 函数创建集合。
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
# 集合
setA = {123, 'abc', complex(1, 2), (1, 2), 123}
# 输出集合，重复的元素被自动去掉
print(setA)
# 成员测试
if 123 in setA:
print("123在setA里")
else:
print("123不在setA里")
# set可以进行集合运算
a = set('abcdefghigklmn')
b = set('abcdefglmops')
# 输出集合a
print(a)
# a和b的差集
print(a - b)
# a和b的并合
print(a | b)
# a和b的交集
print(a & b)
# a和b中不同时存在的元素
print(a ^ b)
8.Dictionary（字典）
1.字典（dictionary）是Python中另一个非常有用的内置数据类型。
2.列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
3.字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。
# 字典
dictA = {}
dictA['one'] = "one-德玛西亚"
dictA[1] = "1-诺克萨斯"
dictB = {'name': "Mr.wildfire", 'age': 21, "sex": "man"}
# 输出dictA中键为one的值
print(dictA["one"])
# 输出dictB中键为name的值
print(dictB["name"])
# 输出完整的字典dictB
print(dictB)
# 输出dictB的所有键
print(dictB.keys())
# 输出dictB的所有值
print(dictB.values())
构造字典的方法（仔细看代码）：
#先创建一个空字典，然后在分别赋值
dictA = {}
dictA['one'] = "one-德玛西亚"
dictA[1] = "1-诺克萨斯"
#创建字典时，便赋值
dictB = {'name': "Mr.wildfire", 'age': 21, "sex": "man"}
#构造函数dict()可以直接从键值对序列中构建字典
dictC=dict([("name","wildfire"),("age",21),("sex","mam")])
#这个情况下，键只能是标识符（数字字母下划线组成，但是不能以数字开头）
dictD = dict(name="human", age="wildfire", sex="man")
dictE = {x: x ** 2 for x in (2, 4, 6)}
注意：
1.字典类型也有一些内置的函数，例如clear()、keys()、values()等
2.字典是一种映射类型，它的元素是键值对。字典的关键字必须为不可变类型，且不能重复
3.创建空字典使用 { }
9.Python数据类型转换
| [int(x [,base])] | 将x转换为一个整数 |
|---|---|
| float(x) | 将x转换到一个浮点数 |
| [complex(real ,imag]) | 创建一个复数 |
| str(x) | 将对象 x 转换为字符串 |
| repr(x) | 将对象 x 转换为表达式字符串 |
| eval(str) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
| tuple(s) | 将序列 s 转换为一个元组 |
| list(s) | 将序列 s 转换为一个列表 |
| set(s) | 转换为可变集合 |
| dict(d) | 创建一个字典。d 必须是一个 (key, value)元组序列。 |
| frozenset(s) | 转换为不可变集合 |
| chr(x) | 将一个整数转换为一个字符 |
| ord(x) | 将一个字符转换为它的整数值 |
| hex(x) | 将一个整数转换为一个十六进制字符串 |
| oct(x) | 将一个整数转换为一个八进制字符串 |
# [int(x [,base])]
# x--字符串或者数字，base--进制数，默认是10进制
# 如果是两个参数的话，x需要转化成字符串,X字符串不能包含除数字字母之外的数
a = 12
a = str(a)
b = int(a, base=16)
print(b)