Python基础（1）
标准数据类型
Python3 中常见的数据类型有：
- Number（数字）
- String（字符串）
- bool（布尔类型）
- List（列表）
- Tuple（元组）
- Set（集合）
- Dictionary（字典）
Python3 的六个标准数据类型中：
- 不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
- 可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。
此外还有一些高级的数据类型，如: 字节数组类型(bytes)。
Number（数字）
Python 数字数据类型用于存储数值。数据类型是不允许改变的,这就意味着如果改变数字数据类型的值，将重新分配内存空间。
数值类型
Python 支持三种不同的数值类型：
- 整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
- 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x \(10^2\) = 250）
- 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
数字类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可。
- int(x) 将 x 转换为一个整数。
- float(x) 将 x 转换到一个浮点数。
- complex(x) 将 x 转换到一个复数，实数部分为 x，虚数部分为 0。
- complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
数字运算
对数的加减乘除都支持，只是一些点需要注意些：
- 将任意两个数相除时，结果总是浮点数，即便这两个数都是整数且能整除的。
- 书写很大的数时，可使用下划线将其中的数字分组，使其更清晰易读
universe_age = 14_000_000_000，Python并不会打印其中的下划线。 - 可在一行代码中给多个变量赋值。
x, y, z = 0, 0, 0 - Python没有内置的常量类型，但一般会使用全大写指出某个变量视为常量，其值应该始终不变。
String（字符串）
在Python中，用引号括起来的都是字符串，其中的引号可以是双引号也可以是单引号。
字符串改方法
方法title()以首字母大写的方式显示每一个单词，即将每个单词的首字母都改为大写。
name = "ada lovelace"
print(name.title())
#打印结果：Ada Lovelace
字符串全部大写方法：name.upper() 字符串全部小写方法：name.lower()
格式化字符串
应用场景在字符串中使用变量的值。这种被称为f 字符串，Python 通过把花括号内的变量替换为其值来设置字符串的格式。
同时花括号内也能调用函数方法。
first_name = "ada"
last_name = "lovelace"
full_name = f"{first_name} {last_name}"
print(full_name)
访问字符串中的值
Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号 [ ] 来截取字符串，字符串的截取的语法格式如下：变量[头下标:尾下标]
List（列表）
列表是一系列按特定顺序排列的元素组成。元素之间没有任何关系。用方括号（[ ]）表示列表，用逗号分隔其中的元素。
列表非常适合于存储程序运行期间可能变化的数据集。
访问列表元素
列表是有序集合，访问列表任意元素，可指出列表的名称，再指出元素的索引，并将后者放入方括号内。
bicycles = ["trek", "cannondale", "redline", "specialized"]
print(bicycles[0].title())
列表与字符串的访问方式一样，索引顺序访问都是从0开始，逆序访问都是从-1开始。
元素的增删改
修改列表元素：
motorcycles = ["honda", "yamaha", "suzuki"]
motorcycles[0] = "ducati"
添加列表元素：
motorcycles.append("ducati") #列表末尾添加元素
motorcycles.insert(0, "ducati") #任意位置添加元素，该位置下的每个元素都右移一个单位
删除列表元素：
del motorcycles[1] #根据索引，删除任意位置下的元素
element = motorcycles.pop() #弹出末尾元素
element = motorcycles.pop(0) #根据索引，弹出任意位置下的元素
motorcycles.remove("ducati") #根据元素值，删除元素
注意事项：
- 删除一个元素，且不再使用它，使用del语句；删除元素还要继续使用它，使用pop()
- 方法remove()只能删除第一个指定的值，若要删除的值在列表中出现多次，需要循环删除
组织列表
使用方法sort()对列表永久排序：
cars = ["bmw", "audi", "toyota", "subaru"]
cars.sort()
使用方法sorted()对列表临时排序：
保留列表元素原来的排列顺序，同时以特定的顺序呈现它们。
sorted(cars) #顺序打印元素
sorted(reverse = True, cars) #逆序打印元素
倒着打印列表：
反转列表元素的排列顺序，使用方法 reverse()，可永久性的修改列表元素的排列顺序。
cars.reverse() #反转打印
确定列表长度： 函数len()获悉列表长度
len(cars) #4
遍历列表
nums = ["alice","david","carolina"]
for iter in nums:
print(iter)
创建数值列表
1、简单使用range() 函数
for value in range(1, 5);
print(value)
2、使用range() 创建数字列表
numbers = list(range(1, 6)) #使用list()将range()的结果直接转换为列表
print(numbers)
3、range() 指定步长
even_numbers = list(range(2, 11, 2))
print(even_numbers)
---------------------------
[2, 4, 6, 8, 10]
4、对数字列表的简单计算
digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(f"min(digits) = {min(digits)}\n")
print(f"max(digits) = {max(digits)}\n")
print(f"sum(digits) = {sum(digits)}\n")
5、列表解析
将for循环和创建新元素的代码合并成一行，并自动附加新元素
squares = [value ** 2 for value in range(1, 11)] #每取出一个元素，都会进行平方的操作
print(squares)
使用部分列表
1、切片，创建切片可指定要使用的第一个元素和最后一个元素的索引
players = ["charles", "martina", "michael", "florence", "eli"]
print(players[0:3]) #遵守左闭右开[?,?),不取右值
print(players[:4]) #若没有指定第一个索引，将自动从列表开头开始
print(players[:4]) #若没有指定第二个索引，则切片终止于列表末尾
print(players[-3:]) #输出倒数后3个元素
2、遍历切片，使用for循环
for iter in players[:3]:
print(iter.title())
3、复制列表
复制列表可创建一个包含整个列表的切片，同时省略起始索引和终止索引。注意这里不是将副本进行赋值，二者是指向同一个列表。
players = ["charles", "martina", "michael", "florence", "eli"]
player1 = players[:]
Tuple（元组）
python将不能修改的值称为不可变的，而不可变的列表被称为元组。元组使用圆括号来标识。定义元组后，可使用索引来访问元组元素。
dimensions = (200, 50)
dimensions[0] = 250 #报错！
#TypeError: "tuple" object does not support item assignment(禁止修改元组)
严格来说，元组是由逗号标识的，圆括号只是让元组看起来更整洁清晰。如果要定义只包含一个元素的元组，必须在这个元素后面加上逗号。
my_t = (3,)
遍历元组
dimensions = (200, 50)
for iter in dimensions:
print(iter)
修改元组元素
虽然不能修改元组的元素，但是可以给存储元组的变量赋值。如果需要存储的一组值在程序的整个生命周期内都不变，就可以使用元组。
dimensions = (200, 50)
dimensions = (400, 100) #更改元组的赋值
Dictionary（字典）
字典是一系列键值对。每个键都与一个值相关联。可以使用键来访问相关联的值。字典用在花括号 ({ }) 中的一系列键值对表示。
alien = {"color":"green", "points":5}
print(alien["color"]) #访问字典中的值
添加键值对
可依次指定字典名、用方括号括起来的键和相关联的值。
alien["x_position"] = 0 #添加键值对
alien["y_position"] = 25 #添加键值对
alien["x_position"] = 75 #修改键对应的值
alien_0 = {} #空字典
emptyDict = dict() #空字典
del alien_0["point"] #删除键值对，彻底删除
alien.clear() # 清空字典
del alien # 删除字典
为避免在访问时指定的键不存在的问题，可使用get方法，返回一个默认值。
point_value = alien.get("points","No point value assigned.")
键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
tinydict = {['Name']: 'Runoob', 'Age': 7} print ("tinydict['Name']: ", tinydict['Name']) #---------------------------------------------------- Traceback (most recent call last): File "test.py", line 2, in <module> tinydict = {['Name']: 'Runoob', 'Age': 7} TypeError: unhashable type: 'list'
遍历字典元素
1、遍历所有键值对
for key, value in user_0.items(): #items() 返回的是一个键值对列表
print(f"\nKey:{key}")
print(f"Value:{value}")
2、遍历字典中的所有键
for name in language.keys(): #keys()返回的是一个列表，其中包含字典中的所有键
print(name.title())
3、按特定顺序遍历字典中的所有键
for name in sorted(languages.keys()):
print(f"{name.title()},thank you for taking the poll")
4、遍历字典中的所有值
for iter in languages.values():
print(iter.title())
这种做法提取字典中所有的值，而没有考虑是否重复。若重复值太多，最终的列表可能包含大量重复项，为剔除重复项，可使用集合set，使得集合中的每个元素都是独一无二的。
for iter in set(languages.values()):
print(iter.title())
Set（集合）
集合（set）是一个无序的不重复元素序列。集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。
可以使用大括号 { } 创建集合，元素之间用逗号 , 分隔， 或者也可以使用 set() 函数创建集合。
set1 = {1, 2, 3, 4} # 直接使用大括号创建集合
set2 = set([4, 5, 6, 7]) # 使用 set() 函数从列表创建集合
注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
元素的增删改
添加元素：
s = set(("Google", "Runoob", "Taobao"))
s.add( x ) #将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。
s.update( x ) #可以添加元素，且参数可以是列表，元组，字典等
s.update({1,3})
print(thisset)
# {1, 3, 'Google', 'Taobao', 'Runoob'}
移除元素：
s.remove( x ) #将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。
s.discard( x ) #移除集合中的元素，且如果元素不存在，不会发生错误
s.pop() #随机删除集合中的一个元素
#set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。
s.clear() #清空集合 s
判断元素是否在集合:
x in s #判断元素 x 是否在集合 s 中，存在返回 True，不存在返回 False。
集合操作
右全包含布尔真：判断 setx 集合的所有元素是否都包含在 sety 集合中
setx.issubset(sety):bool
>>> x = {"a", "b", "c"}
>>> y = {"f", "e", "d", "c", "b", "a"}
>>> x.issubset(y)
True
左全包含布尔真: 判断 sety 集合的所有元素是否都包含在原始 setx 的集合中
setx.issuperset(sety):bool
>>> x = {"a", "b", "c"}
>>> y = {"f", "e", "d", "c", "b", "a"}
>>> y.issuperset(x)
True
右半包含布尔取反：判断集合 sety 中是否有集合 setx 的任一元素（包含返回 False，不包含返回 True）
setx.isdisjoint(sety):bool
合并集合（并集）：(注意：集合元素的去重、唯一性)
setx.union(sety [, setz...]):set
>>> x = {"a", "b", "c"}
>>> y = {"f", "d", "a"}
>>> z = {"c", "d", "e"}
>>> x.union(y, z)
{'c', 'd', 'f', 'e', 'b', 'a'}
左包含差集: 返回集合的差集，即返回的集合元素包含在第一个集合 x 中，但不包含在第二个集合 y(方法的参数)中
setx.difference(sety):set
左引用删除交集（无返回值，即直接修改原内存指向）
setx.difference_update(sety):void
>>> x,y
({'banana', 'cshit', 'vipkwd.com', 'alipay'}, {'google', 'runoob', 'facebook', 'alipay'})>>> type(x.difference_update(y))
<class 'NoneType'>
>>> x,y
({'banana', 'cshit', 'vipkwd.com'}, {'google', 'runoob', 'facebook', 'alipay'})
左右差集：返回两个集合中不重复的元素集合，即会移除两个集合中都存在的元素
setx.symmetric_difference(sety):set
左引用删除交集且引用追加右差集（引用操作，无返回值）
setx.symmetric_difference_update(sett):void
左右交集：返回两个或更多集合中都包含的元素，即交集
setx.intersection(sety[, seyz....]):set
左引用交集
setx.intersection_update(sety):void
辅助理解：所有提到 “引用” 俩字的都是函数内部直接操作内存指向，故无返回值；反之：如果一个函数没有实质返回值，那么它一定是在函数内部改变了其他位置内容， 否则这个函数就是 dog shit，因为它不具有实质的意义。