Python全栈开发实战学习2

第二章 Python数据类型

2.1 变量及身份运算补充

变量的创建与id

1. 一个变量名一个值
   name = ‘oldboy’
   
2. 两个变量名一个值
   name1 = ‘oldboy’
   name2 = ‘oldboy’
   
3. Python解释器对短字符串和[-5,257)范围内的数字做了优化，已达到节省空间的目的。
4. 为了更直接地认识变量的创建，我们可以使用id()函数来查看变量
   
   

身份运算

运算符	描述	实例
is	is是判断两个标识符是不是引用同一个对象	x is y，类似id(x) == id(y)
is not	is not 是判断两个标识符是不是引用的不同对象	x is not y，类似id(x) != id(y)

字符编码

参考博文 https://www.cnblogs.com/happyday56/p/4135845.html

2.2 基本数据类型——数字

布尔型

布尔型只有两个值：True 和 False
之所以将bool型归为数字，是因为我们也习惯用1表示True，用0表示False。

整型

Python中的整型默认为int型，用十进制表示，此外也支持二进制、八进制和十六进制。

浮点型

简单地说类似于科学记数法，标准可见IEEE 754
关于小数不精准的问题，Python默认是17位精度，即小数点后16位，但后面不怎么精确。
如何满足计算时的高精度要求呢？可以借助decimal模块的“getcontext”和“Decimal”方法。

>>> a = 3.141592653513651054608317828332
>>> a
3.141592653513651
>>> from decimal import *
>>> getcontext()
Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])
>>> getcontext().prec = 50
>>> a = Decimal(1)/Decimal(3)#注，在分数计算中结果正确，如果直接定义超长精度小数会不准确
>>> a
Decimal('0.33333333333333333333333333333333333333333333333333')
>>> 
>>> a = '3.141592653513651054608317828332'
>>> Decimal(a)
Decimal('3.141592653513651054608317828332')

# 不推荐！字符串格式化方式，可以显示但是计算和直接定义都不准确，后面的数字没有意义
>>> a = ("%.30f") % (1.0/3)
>>> a
'0.333333333333333314829616256247'

基本数据类型——字符串

创建

a = “Hello world!”

特性

按照从左到右顺序定义字符集合，下标从0开始顺序访问，有序。
Python中没有char类型，可以把字符串类型看作成char类型的数组。

补充1：字符串的单引号和双引号无法取消特殊字符的含义，如果想让引号内所有字符均取消特殊意义，在引号前面加 r ，如name = r’l\thf’

>>> name = 'l\thf'
>>> name
'l\thf'
>>> name = r'l\thf'
>>> name
'l\\thf'
>>> 

补充2：unicode 字符串与 r 连用必须在 r 前面，如：name = ur’l\thf’
可参考：https://blog.csdn.net/u010496169/article/details/70045895
　　　　https://blog.csdn.net/joeyon1985/article/details/41981105

常用操作

python字符串操作常用操作，如字符串的替换、删除、截取、复制、连接、比较、查找、分割等。

1. 索引

>>> s = 'hello'
>>> s[1]
'e'
>>> s[-1]
'o'
>>> s.index('e')
1

2. 查找

>>> s.find('e')
1
>>> s.find('i')
-1

3. 移除空白

>>> s = "    hello,world!    "
>>> s.strip()  #移除所有空白
'hello,world!'

>>> s = "    hello,world!    "
>>> s.lstrip()  #移除左边空白
'hello,world!    '

>>> s = "    hello,world!    "
>>> s.rstrip()  #移除右边空白
'    hello,world!'

>>> s = "***hello,world***"
>>> s.strip(*)
SyntaxError: invalid syntax
>>> s.strip('*')
'hello,world'

4. 长度

>>> s = "hello,world"
>>> len(s)
11

5. 替换

>>> s = "hello,world"
>>> s.replace('h','H')
'Hello,world'

6. 切片

>>> s = "abcdefghijklmn"
>>> s[0:7]
'abcdefg'
>>> s[7:14]
'hijklmn'
>>> s[7:]
'hijklmn'
>>> s[:]
'abcdefghijklmn'
>>> s[0:7:2]
'aceg'
>>> s[::2]
'acegikm'
>>> s[::-1]
'nmlkjihgfedcba'

字符串的工厂函数

参考：https://www.cnblogs.com/panwenbin-logs/p/5497577.html?utm_source=tuicool&utm_medium=referral

2.3 基本数据类型——列表

定义和创建

定义：[]内以逗号分隔，按照索引存放各种数据类型，每个位置代表一个元素
创建：

list_test = [“张三”, "李四", "123"]
# 或
list_test = list("张三")
# 或
list_test = list([“张三”, "李四", "123"])

特性

1. 可存放多个值
2. 按从左到右顺序索引，下标从0开始，有序
3. 可修改指定索引位置对应的值，可变

常用操作

>>> list_test = ['Alex',"Martin","Sarah","Jack"]

1. 索引

>>> list_test[0]
'Alex'
>>> list_test[-1]
'Jack'

2. 切片

>>> list_test[0:2]
['Alex', 'Martin']
>>> list_test[::2]
['Alex', 'Sarah']

3. 追加

>>> list_test.append("Mike")
>>> list_test
['Alex', 'Martin', 'Sarah', 'Jack', 'Mike']

4. 删除

>>> list_test
['Alex', 'Martin', 'Sarah', 'Jack', 'Mike']
>>> list_test.remove('Sarah')
>>> list_test
['Alex', 'Martin', 'Jack', 'Mike']
>>> list_test.pop()
'Mike'
>>> list_test
['Alex', 'Martin', 'Jack']

5. 长度

>>> list_test
['Alex', 'Martin', 'Jack']
>>> len(list_test)
3

6. 包含

>>> list_test
['Alex', 'Martin', 'Jack']

>>> 'sarah' in list_test
False
>>> 'Martin' in list_test
True
>>> for i in list_test:
	print(i)

	
Alex
Martin
Jack

2.4 基本数据类型——元组

定义和特性

定义：与列表类似，只不过[]改成()
特性：

1. 可存放多个值
2. 不可变
3. 按照从左到右顺序定义元组元素，下标从0开始顺序访问，有序

元组的创建

>>> ages = (11,22,33,44,55)
# 或
>>> ages = tuple(11,22,33,44,55)

常用操作

1. 索引

>>> ages = (11,22,33,44,55)
>>> ages[0]
11
>>> ages[3]
44
>>> ages[-1]
55

2. 切片

# 同list

3. 循环

>>> for age in ages:
	print(age)

	
11
22
33
44
55

4. 长度

>>> len(ages)
5

5. 包含

>>> 11 in ages
True
>>> 66 in ages
False
>>> 11 not in ages
False
>>> 66 not in ages
True

元组特性详解

1. 可存放多个值
   如果元组中只有一个值

t = (1,)
t = (1) # <==> t = 1

元组中不仅可以存放数字、字符串，还可以存放更加复杂的数据类型。
2. 不可变
元组本身不可变，如果元组中还包含其他可变元素，这些可变元素可以改变。

2.5 可变、不可变数据类型和hash

可变与不可变

可变类型	不可变类型
列表	数字
	字符串
	元组

可变与不可变的含义：对其进行修改时，可变类型在内存的位置不变，内容改变，不可变类型内容改变，内存位置也会改变，即不是原来的那个对象了。字符串，元组更是不允许对原有的内容进行替换修改

Hash

hash函数是一种映射关系，便于索引，hash值可能会出现冲突。只有不可变的类型才能够被hash。利用hash()可以查看Python中的hash值。先不做太深入的研究了。

2.6 基本数据类型——字典

字典是Python语言中唯一的映射类型。

定义：{key1:value1,key2:value2}

键与值之间用冒号“:”隔开
项与项之间用逗号“,”隔开

特性

1. key-value 结构
2. key必须hash、且必须为不可变数据类型、必须唯一
3. 可存放任意多个值、可修改、可以不唯一
4. 无序

字典的创建

person = ["name":"Martin","age":20]
# 或
person = dict(name="Martin",age=20)
# 或
person = dict(["name":"Martin","age":20])
# 或
person = dict((['name','袁浩'],['文州',18]))
# 或
person = dict.fromkeys(seq,100)#如果没有100，则默认为None

# 例子
>>> person = dict.fromkeys(['k1','k2'],[])
>>> person
{'k1': [], 'k2': []}
>>> person['k1'].append(1)
>>> person
{'k1': [1], 'k2': [1]}

常见操作

1. 键、值、键值对

1.dict.keys() 返回一个包含字典所有key的列表
2.dict.values() 返回一个包含字典所有value的列表
3.dict.items() 返回一个包含所有(键，值)元组的列表
4.dict.iteritems(),dict.iterkeys(),dict.itervalues() 与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表

2. 新增

1.dict[’'new_key"] = “new_value”
2.dict.setdefault(key,None) # 如果字典里不存在key值，将由dict[key] = default为它赋值

3. 删除

1.dict.pop(key) 或 dict.pop([key,value])
2.dict.clear() # 删除字典中的所有项或元素

4. 修改

1.dict[“new_key”] = “new_value” # 如果字典中存在则替换，不存在则添加
2.dict.update(dict2) # 将dict2中的键值添加到dict中

5. 查看

1.dict[“key”]
2.dict.get(key,default = None) # 返回字典中key对应的值，如果不存在则返回default值

6. 循环

1.for k in dict.keys()
2.for k,v in dict.items()
3.for k in dict

7. 长度

len(dict)

2.7 基本数据类型——集合

集合是Python3中为了解决类似数学集合上交、并、补、差等关系而定义的数据类型。满足数学上集合的性质，并且自动整理内容以满足集合性质。

创建

直接一个大括号{}即可
l = {1,2,3,4,5}
s = {4,5,6,7,8}

常用操作

1. 增加

单个元素的增加：add()  # 类似于列表中的append()
>>> l = {1,2,3,4,5}
>>> s = {4,5,6,7,8}
>>> l.add(0)
>>> l
{0, 1, 2, 3, 4, 5}
对序列的增加：update()  # 类似于extend方法，update方法可以支持同时传入多个参数
>>> l.update([7,8],[9,10])
>>> l
{0, 1, 2, 3, 4, 5, 7, 8, 9, 10}

2. 删除
   集合删除单个元素有两种方法：discard()和remove()

# 元素不在集合中时：discard()不会抛出异常，而remove()会抛出异常
>>> l
{0, 1, 2, 3, 4, 5, 7, 8, 9, 10}
>>> l.discard(11)
>>> l.remove(12)
Traceback (most recent call last):
  File "<pyshell#48>", line 1, in <module>
    l.remove(12)
KeyError: 12

pop()：由于集合是无序的，所以pop返回的结果不能确定，集合为空时会抛出异常
clear():清空集合

2.8 基本数据类型——collections

参考：https://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001411031239400f7181f65f33a4623bc42276a605debf6000