Python3 基本数据类型

Python 中的变量不需要声明。变量赋值以后该变量才会被创建。在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

Python允许这样赋值

a = b = c = 1 # 从后向前赋值，三个变量被赋予相同的数值
a, b, c = 1, 2, "runoob" #  1 和 2 的分配给a 和 b，"runoob" 分配给c。

标准数据类型

Python3 中有六个标准的数据类型：

Number（数字） String（字符串） Tuple（元组） List（列表）Set（集合） Dictionary（字典）

• 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

• 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

Number（数字）

Python3 支持 int、float、bool、complex（复数）（a + bj，或者 complex(a,b) 表示）

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d)) # 内置的type() 函数可以查询变量所指的对象类型。
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>
>>> print(isinstance(a, int))  # 此外还可以用 isinstance 来判断
True

注意：Python3 中，bool 是 int 的子类，所以True 和 False 可以和数字相加，

 True==1、False==0 会返回 True，但可以通过 is 来判断类型。

a, b, c, d = 10, True, 1.1, 2 + 2j # 当你为变量赋值时，Number 对象就会被创建
del a, b # 使用del语句删除变量a、b对内存中值对象的引用
print(a) # NameError: name 'a' is not defined

Tuple（元组）

元组写在小括号 () 里，元素之间用逗号隔开。元组中的元素类型无要求。您在字符串中的操作也适用元组，例如下标索引、加号拼接、乘号重复

tuple = ('abc', 786, True)
print(2 * tuple) # ('abc', 786, True, 'abc', 786, True)
print(tuple[1]) # 786
print(tuple[1:]) # (786, True)
print(tuple + (1, 2)) # ('abc', 786, True, 1, 2)
tuple[0] = 11 # TypeError: 'tuple' object does not support item assignment

构造空元组：tuple = ()
构造一个元素的元组：tuple2 = (1, ) # 一个元素，需要在元素后添加逗号
# print(type(tuple2)) 是<class 'tuple'>
# print(type((1))) 是<class 'int'>

虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表,因为你在操作list而不是tuple:
tuple = ([1, 2, 3], )
tuple[0][0] = 4
print(tuple) # ([4, 2, 3],)

List（列表）

列表是写在方括号 [] 之间、用逗号分隔开元素，元素类型无要求。您在字符串、元组中的操作也适用列表，例如下标索引、加号拼接、乘号重复：

list = [1, 'abc', False]
print(list[0]) # 1
print(list[1::2]) # ['abc']
print(list * 2) # [1, 'abc', False, 1, 'abc', False]
print(list + [4, 5]) # [1, 'abc', False, 4, 5]
print(type([])) # <class 'list'>
print(type([1])) # <class 'list'>,没有二义性，所以不用加逗号
list[1:] = [888]; # list[1:] = 888是错的，你家int赋给list？
print(list) # [1, 888]
print(list[-1::-1]) # [888, 1]，字符串、元组、列表等的步长都可以是负的，技巧：翻转

Set（集合）

集合的元素不能重复，所以集合功能是进行成员删除重复元素，由于去重，所以测试某值在不在集合里比较快，所以功能二是成员测试。可以使用大括号 { } 或者 set() 函数创建集合，set()只接受一个参数。注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

par = {1, 1, 22}
print(par) # {1, 22}
a = set('abracadabra')
b = set('alacazam')
print(a) # {'r', 'c', 'd', 'b', 'a'}
print(b) # {'l', 'c', 'z', 'a', 'm'}
print(a - b)     # a 减 b 的差集 {'r', 'b', 'd'}
print(a | b)     # a 和 b 的并集 {'b', 'c', 'a', 'z', 'm', 'r', 'l', 'd'}
print(a & b)     # a 和 b 的交集 {'c', 'a'}
print(a ^ b)     # a 和 b 中不同时存在的元素 {'z', 'b', 'm', 'r', 'l', 'd'}
# 理解：异或嘛，记元素在集合里为1，只有1异或0才能成，即a 和 b 中不同时存在的元素

Dictionary（字典）

我们开发中常需要存储键值对，其他语言或许是借助对象，py可以用字典。列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。字典是一种映射类型，字典用 { } 标识，虽然Set也是{ }，但是字典的元素是键值对，而Set不可以。字典是一个无序的 键(key) : 值(value) 的集合。键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。

# 先定义后申明：
dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"
print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
tinydict = {"name": "runoob","code":1, "site": 'www.runoob.com'}
print (tinydict)          # {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
print (tinydict.keys())   # 输出所有键 dict_keys(['name', 'code', 'site'])
print (tinydict.values()) # 输出所有值 dict_values(['runoob', 1, 'www.runoob.com'])
print (type(tinydict.keys())) # <class 'dict_keys'>

选学：构造函数 dict() 可以直接从键值对序列中构建字典如下

>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Runoob': 1, 'Google': 2, 'Taobao': 3}

数据类型转换

隐式类型转换

较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。

print(type(123 + 1.23)) # <class 'float'>

显式类型转换

print(123 + "456") # TypeError: unsupported operand type(s) for +: 'int' and 'str'
# 整型和字符串类型进行运算，就可以用强制类型转换来完成。

print(int(2.8)) # 2
print(float(1)) # 1.0
print(str(2)) # 2

汇总：

int(x)、 float(x)、complex(real, [imag])、 str(x)、 eval("'1 + 2 '") # ‘1 + 2’ # 去除一层引号

tuple(x)、 list(x)、 set(x)、 dict(d) # 创建一个字典。d 必须是一个 (key, value)元组序列

chr(97) # a、 ord('a') # 97、 hex(15) # 0xf、oct(10) # 0o12

range()

range(从哪默认0[,取不到哪默认取至最后,步长])

for x [not] in 某

dic = {1:2, 3:4}
for x in  dic:
    print(x) # 1 3
    print(dic[x]) # 2 4

for x in 'abc':
    print(x) # a\nb\nc

for x in [(1, 2), (3, 4)] : # for后面接一个变量只是简单的一层迭代
    print(x) # (1, 2)和(3, 4)
​
for a, b in [(1, 2), (3, 4)] : # for后面接多个变量就是深入一层迭代了，这个道理不限元组、列表等
    print('a=' + str(a)) # a=1和3
    print('b=' + str(b)) # b=2和4
    
for a, b, c in [(1, 2, 3), (4, 5, 6)] :
    print('a=' + str(a)) # a=1和4
    print('b=' + str(b)) # b=2和5
    print('c=' + str(c)) # a=3和6

其实类似的穿透效应也存在于变量赋值：

a = (1, 2 , 3) # a是元组(1, 2, 3),等号左边单个变量没有穿透
a, b, c = 1, 2 , 3 # a是1，b是2，c是3
a, b, c = (1, 2 , 3) # a是1，b是2，c是3 # 穿透了
a, b, c = [1, 2 , 3] # a是1，b是2，c是3 # 穿透了
a, b = [(1, 2, 3), (4, 5, 6)] # a=(1, 2, 3),b=(4, 5, 6) # 穿透了
a, b, c = [(1, 2, 3), (4, 5, 6)] # ValueError: not enough values to unpack (expected 3, got 2)

Python 推导式

推导式是将range 区间、元组、列表、字典和集合等数据类型转换为元组、列表、字典和集合等数据类型，且具有筛选条件和表达式转换功能的手段，例如你可以从元组里筛选出偶数，结果取其平方，最后组成列表。

元组推导式

(表达式 for 变量 in Sequence ) 或 (表达式 for 变量 in Sequence if 条件 )
# Sequence可以是range 区间、元组、列表、字典和集合等数据类型
# 元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象，使用 tuple() 函数，可以直接将生成器对象转换成元组

print([x for x in [1, 2, 3] if x > 2]) # [3]
print((x for x in (1, 2, 3) if x > 2)) # <generator object <genexpr> at 0x0000025C11818DD0>
print(tuple((x for x in (1, 2, 3) if x > 2))) # (3,)

列表推导式

[表达式 for 变量 in Sequence]  或者 [表达式 for 变量 in Sequence if 条件]
# Sequence可以是range 区间、元组、列表、字典和集合等数据类型
解释：[]代表将里面的元素组成列表，for in if是筛选元素，表达式是输入筛选出的元素，输出表达式的结果。

过滤掉长度小于或等于3的字符串列表，并将剩下的转换成大写字母：

>>> 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']

找出30 以内可以被 3 整除的整数：

>>> multiples = [i for i in range(30) if i % 3 == 0]
>>> print(multiples)
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

集合推导式

{ 表达式 for 变量 in Sequence } 或 { 表达式 for 变量 in Sequence if 条件 }
# Sequence可以是range 区间、元组、列表、字典和集合等数据类型
# 用法也完全相同,用{ }罢了，直接输出集合

print({x for x in range(1, 4) if x > 2}) # {3}

字典推导式

{ 键表达式: 值表达式 for x in Sequence } 或 
{ 键表达式: 值表达式 for x in Sequence if 条件 }
# Sequence可以是range 区间、元组、列表、字典和集合等数据类型

dic = {x: x**2 for x in (2, 4, 6)}
print(dic) # {2: 4, 4: 16, 6: 36}

高玩

结果值1 if 判断条件 else 结果值2  for 变量名 in Sequence [if 条件]
# 但是好像不适用于字典，可能式子太复杂了吧

multiples = [i if i == 2 else i ** 2 for i in (2, 3, 4)]
print(multiples) # [2, 9, 16]