Python学习之路-----基础数据类型

基础数据类型

python版本 3.7.7

Python 中的变量不需要声明。但是每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在Python中，变量就是变量，没有类型。我们所说的“类型”是变量所指内存中对象的类型。即

a = 7，其中a是一个变量，也可以说成是一种标签，它指向的是一个存储着类型为int型且值为7的内存空间。

Python变量赋值

Python允许同时为多个变量赋值：

a = b = c = d = 100

也可以对多个对象指定多个变量（且变量类型可不一致)：

a,b,c =  1 , 5.20, "Iloveyou"
print(a,b,c)

1 5.2 Iloveyou

标准数据类型：

Number(数字)、String(字符串)、Tuple(元组)为不可变数据；

不可变数据在Python中作为函数参数传递时相当于C/C++的值传递，在函数中赋值时会创建一个其副本，并不会影响原本的值。

List(列表)、Set(集合)、Dictionary(字典)为可变数据；

可变数据在Python函数作为参数传递时相当于C++中的引用传递，在函数中修改会造成实参被修改。

Number（数字) :

int(只有一种，长整型)、float、bool、complex

可以使用type()内置函数查看变量所指对象的类型

a,b,c =  1 , 5.20, "Iloveyou"
print(a,b,c)
print(type(a),type(b),type(c))

'''
1 5.2 Iloveyou
<class 'int'> <class 'float'> <class 'str'>
'''

此外还可以用 isinstance 来判断：

a,b,c =  1 , 5.20, "Iloveyou"
print(isinstance(a,int))

'''
True
'''

isinstance 和 type 的区别在于：

• type()不会认为子类是一种父类类型。
• isinstance()会认为子类是一种父类类型。

class A:
    pass

class B(A):  #B类为A类的子类
    pass

print(isinstance(A(),A))
print(isinstance(B(),A))

print(type(A()) == A)
print(type(B()) == A)

'''
True
True
True
False
'''

Number（数字）的数值运算

+、-、*、/（除法，得到一个浮点数）、//（整除，得到一个整数）、%（取余）、**（乘方）

字符串（String)

python中单引号和双引号使用完全相同。

字符串可以用 + 运算符连接在一起，用 * 运算符重复

a = "I "
b = "Love "
c = "You"
fin = a+b+c
print(fin)
fin = a*3
print(fin)

I Love You
I I I 

Python中的字符串不能改变。

Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。

Python 中的字符串有两种索引方式（顺序和逆序），从左往右以 0 开始，从右往左以 -1 开始。

字符串的截取的语法格式如下：变量[头下标:尾下标:步长] ，截取的长度为 (tag_tail - tag_head - 1)。

love = "I Love You!"
print(love[0])
print(love[-2])
print(love[0:7])     #截取的长度为 tag_tail - tag_head - 1,即从0至(7-1)
print(love[0:10:2])
print(love[-5:-1:1])
'''
I
u
I Love 
ILv o
 You
'''

转义字符 \

python使用反斜杠作为转义字符，若不想转义，可以在字符串前加r，表示原生字符串：

love = "I \nLove \nYou!"
love_r = r"I \nLove \nYou!"
print(love)
print(love_r)

'''
I 
Love 
You!
I \nLove \nYou!
'''

List(列表)

python中的列表很重要，可以模拟堆栈、队列的数据结构。
列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [ ] 之间、用逗号分隔开的元素列表。

my_list = ['I','L','o','v','e','Y','o','u','!',520,2.25]

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。（注意返回的还是一个列表）

截取格式： 变量[头下标:尾下标]

my_list = ['I','L','o','v','e','Y','o','u','!',520,2.25]
another = ["hello world","hello boy"]
print(my_list)
print(my_list[0::2]) #步长为2读取
print(my_list[3:7])
print(my_list[-3:-1])
print(my_list * 2)
print(my_list[-1::-1])  #逆向读取
print(my_list + another)

'''
['I', 'L', 'o', 'v', 'e', 'Y', 'o', 'u', '!', 520, 2.25]
['I', 'o', 'e', 'o', '!', 2.25]
['v', 'e', 'Y', 'o']
['!', 520]
['I', 'L', 'o', 'v', 'e', 'Y', 'o', 'u', '!', 520, 2.25, 'I', 'L', 'o', 'v', 'e', 'Y', 'o', 'u', '!', 520, 2.25]
[2.25, 520, '!', 'u', 'o', 'Y', 'e', 'v', 'o', 'L', 'I']
['I', 'L', 'o', 'v', 'e', 'Y', 'o', 'u', '!', 520, 2.25, 'hello world', 'hello boy']
'''

元组（Tuple)

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

my_list = ('I','L','o','v','e','Y','o','u','!',520,2.25)
another = ("hello world","hello boy")
print(my_list)
print(my_list[0::2])
print(my_list[3:7])
print(my_list[-3:-1])
print(my_list * 2)
print(my_list[-1::-1])
print(my_list + another)

'''
('I', 'L', 'o', 'v', 'e', 'Y', 'o', 'u', '!', 520, 2.25)
('I', 'o', 'e', 'o', '!', 2.25)
('v', 'e', 'Y', 'o')
('!', 520)
('I', 'L', 'o', 'v', 'e', 'Y', 'o', 'u', '!', 520, 2.25, 'I', 'L', 'o', 'v', 'e', 'Y', 'o', 'u', '!', 520, 2.25)
(2.25, 520, '!', 'u', 'o', 'Y', 'e', 'v', 'o', 'L', 'I')
('I', 'L', 'o', 'v', 'e', 'Y', 'o', 'u', '!', 520, 2.25, 'hello world', 'hello boy')
'''

虽然元组的元素不能修改，但是可以重新让变量指向一个新的元组：

connect = (0,)
print(connect)
connect =  my_list + another
print(connect)
'''
(0,)
('I', 'L', 'o', 'v', 'e', 'Y', 'o', 'u', '!', 520, 2.25, 'hello world', 'hello boy')
'''

其实，可以把字符串看作一种特殊的元组。

虽然元组tuple的元素不可改变，但它可以包含可变的对象，比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup_empty = () #空元组
tup_one = (3,) #！！！只有一个元素的元组，如果去掉，会将tup_one指向一个int类型变量3

集合（Set）

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。集合是无序且不重复的，有重复元素将只保留一个。

使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

empty_d = {} #创建一个空字典
empty_s = set() #创建一个空集合

集合测试及运算：

student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
 
print(student)   # 输出集合，重复的元素被自动去掉
 
# 成员测试
if 'Rose' in student :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')
 
 
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
 
print(a)
print(b)
print(a - b)     # a 和 b 的差集
 
print(a | b)     # a 和 b 的并集
 
print(a & b)     # a 和 b 的交集
 
print(a ^ b)     # a 和 b 中不同时存在的元素

'''
{'Jim', 'Rose', 'Jack', 'Tom', 'Mary'}
Rose 在集合中
{'r', 'd', 'b', 'a', 'c'}
{'l', 'm', 'z', 'a', 'c'}
{'b', 'r', 'd'}
{'r', 'd', 'b', 'a', 'c', 'z', 'l', 'm'}
{'a', 'c'}
{'z', 'r', 'l', 'm', 'd', 'b'}
'''

Dictionary（字典）

列表是有序的对象集合，字典是无序的对象集合。

两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合

其中，key(键)必须使用不可变类型：string、tuple、number

dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"
 
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
 
print (dict)
print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值

'''
{'one': '1 - 菜鸟教程', 2: '2 - 菜鸟工具'}
1 - 菜鸟教程
2 - 菜鸟工具
{'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
dict_keys(['name', 'code', 'site'])
dict_values(['runoob', 1, 'www.runoob.com'])
'''

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

print(dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)]))
print({x: x**2 for x in (2,4,5)})
print(dict(a=1,b=2,c=3))

'''
{'Runoob': 1, 'Google': 2, 'Taobao': 3}
{2: 4, 4: 16, 5: 25}
{'a': 1, 'b': 2, 'c': 3}
'''