【从零学Python_1.2】基础数据类型

int（整型）
float（浮点数）
complex（复数）
bool（布尔值）
string（字符串）
list（列表）
tuple（元组）
set（集合）
dict（字典）

int整型：

Number数字类型；
整数，长度没有限制，能一直大到占满可用内存；
数字之间可以加"_"分割，不影响数值，只是为了阅读方便。

num = 123_456_789
print(num)      # 输出123456789

# 默认十进制
print(123)      # 123
# 二进制0b开头
print(0b1010)   # 10
# 八进制0o开头
print(0o157)    # 111
# 十六进制0x开头
print(0x19A)    # 410

float浮点数：

Number数字类型；
数字之间也可以加"_"分割，不影响数值，只是为了阅读方便。

a = 1.2         # 1.2
b = .12         # 0.12
c = 12.         # 12.0
d = 1_2.3_4     # 12.34

complex复数：

Number数字类型；
写法：x + yj ，x 是实部，y 是虚部。

c = 1+2j
print(c)    # (1+2j)

bool布尔值：

Number数字类型，bool是int的子类；
True==1，False==0，可以作为整型直接参与计算。

b1 = True
b2 = False
print(b1+b2, b1+5)  # 1 6

string字符串：

单行字符串表示方式：单引号('')或双引号("")；
多行字符串表示方式：开始和结尾都加三个单引号/双引号;
单引号和双引号没有任何区别，表示的字符串值相等；
Python没有字符的概念，只有长度为1的字符串，'a' == "a"，都是字符串。

str1 = '单行字符串'
str2 = "单行字符串"
str3 = '''
    多行字符串
    多行字符串
    '''
str4 = """
    多行字符串
    多行字符串
    """

print(str1 == str2)     # True
print(str3 == str4)     # True

字符串加法：加号(+)可以把两个字符串连接为一个新的字符串；

字符串乘法：星号(*)可以把字符串拷贝指定数量并连接为一个新字符串；

print('hello ' + 'world')    # hello world
print('hello ' * 3)          # hello hello hello

字符串索引：string[下标]，正序从0开始，倒序从-1开始（-1就是最末尾一个字符，-2就是末尾倒数第二个字符）；

st = 'hello'
print(st[0], st[1], st[-2], st[-1])     # h e l o

字符串截取：string[开始下标,截止下标]，下标取左不取右，不包含截止下标本身，零和正数表示正序，负数表示倒序；

st = 'hello'
print(st[0:3], st[0:-2])     # hel hel

list列表：

有序的序列，序列中元素的类型可以不同，用方括号[*,*,*]标识，元素之间逗号(,)分割。

声明：

lst = ['0', 1, 2.3, True, 5]
lst = []        # 空列表
lst = list()    # 空列表

索引和截取：

与string字符串同理，下标正序从0开始，倒序从-1开始，截取时下标取左不取右

（常规使用建议一个list只存放同一类型的元素）

lst = ['0', 1, 2.3, True, 5]

print(lst[0])       # 0
print(lst[-1])      # 5

print(lst[0:2])     # ['0', 1]
print(lst[1:-2])    # [1, 2.3]

加法和乘法：

与string字符串同理，加法可以把两个list连接为一个新的list；乘法可以把一个list拷贝指定数量并连接为一个新的list。

lst1 = [1, 2, 3]
lst2 = [4, 5, 6]

lst3 = lst1 + lst2
lst4 = lst1 * 2

print(lst3)     # [1, 2, 3, 4, 5, 6]
print(lst4)     # [1, 2, 3, 1, 2, 3]

遍历：

for item in list:
    print(item)

推导式：（从一个数据序列构建另一个新的数据序列的结构体）

[表达式 for 变量 in 列表] 
[out_exp_res for out_exp in input_list]

[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]

dict字典：

无序的序列，元素是键值对(key, value)，key必须唯一不能重复，必须使用不可变类型，通过key可以快速定位到value；

key的类型可以不同，value的类型也可以不同。用方括号[*,*,*]标识，元素之间逗号(,)分割，元素内冒号(:)分割key和value。

声明：

dic = {'name': 'xiaoming', 'age': 18}
dic = {}        # 空字典
dic = dict()    # 空字典

通过key索引到value：

str1 = dic['name']                  # 如果输入的key不存在，dic[]会报错
str2 = dic.get('name')              # dic.get()不会报错
print(str1, str2, str1 == str2)     # xiaoming xiaoming True

字典不支持加法和乘法

推导式：

{ key_expr: value_expr for value in collection }
{ key_expr: value_expr for value in collection if condition }

tuple元组：

与list序列类似，有序的序列，序列中元素的类型可以不同，用小括号(*,*,*)标识，元素之间逗号(,)分割。与list不一样的是，tuple元组是不可变类型，声明后就不能再更改，速度比list快。

声明：

tup = ('str', 1, 2, 3.4, 5.6)
tup = ()         # 空元组
tup = tuple()    # 空元组
tup = (1,)       # 一个元素的元组，后面要加逗号，不然会识别为int

索引和截取：

与list列表同理，下标正序从0开始，倒序从-1开始，截取时下标取左不取右

tup = ('str', 1, 2, 3.4, 5.6)

print(tup[0])       # str
print(tup[-1])      # 5.6

print(tup[0:2])     # ('str', 1)
print(tup[1:-2])    # (1, 2)

加法和乘法：

与list列表同理，加法可以把两个tuple连接为一个新的tuple；乘法可以把一个tuple拷贝指定数量并连接为一个新的tuple。

tup1 = (1, 2, 3)
tup2 = (4, 5, 6)

tup3 = tup1 + tup2
tup4 = tup1 * 2

print(tup3)     # (1, 2, 3, 4, 5, 6)
print(tup4)     # (1, 2, 3, 1, 2, 3)

推导式：

(expression for item in Sequence )
(expression for item in Sequence if conditional )

set集合：

无序且不重复的序列，序列中元素的类型可以不同，用花括号{*,*,*}标识，元素之间逗号(,)分割。

声明：

sett = {'0', 1, 2.3}
sett = set()    # 空集合
# sett = {}     不能使用{}，已被声明空字典占用

因为集合是无序的，声明后会自动去重；但是支持索引和截取，也不支持加法和乘法。

sett = {1, 1, 2, 2, 3, 3}
print(sett)     # {1, 2, 3}

推导式：

{ expression for item in Sequence }
{ expression for item in Sequence if conditional }

附1（标识符和类型）：

id()：获取对象的唯一标识符(对象的内存地址)，是一个整数；
type()：获取对象的类型。

test = 123
print(id(test))     # 4417458224
print(type(test))   # <class 'int'>

附2（可变类型与不可变类型）：

定义：

不可变类型：数据不可以在原有内存上修改，修改后内存地址变化（Number数字、String字符串、Tuple元组）

可变类型：数据可以在原有内存上修改，修改后内存地址不变（List列表、Dict字典、Set集合）

说明：

不可变类型示例：只能重新赋值修改数据，赋值后会改变内存

num = 1
print(id(num))      # 4354294000
num = 2
print(id(num))      # 4354294032

str1 = 'hello'
print(id(str1))     # 4355664944
str1 = 'world'
print(id(str1))     # 4356996976

tup1 = (1, 2, 3)
# tup1[0] = 4     # 报错，元组不允许修改

可变类型示例：可以单独修改元素，修改元素后序列的内存不变；重新赋值后也会改变内存

lst1 = [1, 2, 3]
print(id(lst1))     # 4355635392
lst1[0] = 4
lst1[1] = 5
lst1[2] = 6
print(id(lst1))     # 4355635392
lst1 = [4, 5, 6]
print(id(lst1))     # 4355658880

附3（Number与String转换）：

int,float,string之间相互转换：

a = 12
stra = str(a)
floa = float(a)

b = 3.4
strb = str(b)
intb = int(b)   # 只取整数部分，舍弃小数部分

c = '5'
d = '6.7'
intc = int(c)       # 字符串本身只有数字，没有其他字符
flod = float(d)     # 字符串本身只有数字和小数点，没有其他字符

附4（各类型转Bool）：

对象的值作为布尔值用于计算，值为False的情况：

int整型、float浮点数、complex复数，值 == 0
str字符串、list列表、tuple元组、set集合、dict字典，值 == None 或空序列

num1 = 0      num2 = 0.0
str1 = None   str2 = ''
lst1 = None   lst2 = []
dic1 = None   dic2 = {}
tup1 = None   tup2 = ()
set1 = None   set2 = set()

num = 0
if num:
    print(True)
else:
    print(False)
# False

str1 = ''
if str1:
    print(True)
else:
    print(False)
# False

lst = []
if lst:
    print(True)
else:
    print(False)
# False