一、Python的基础数据类型
1.1 Python的基本数据类型
(1) 可变数据类型： List、Dictionary、Set
(2) 不可变数据类型： Number、String、Tuple
1.2 判断数据的类型
内置的 type() 函数可以用来查询变量所指的对象类型 # 不会认为子类是父类类型 print(type(a)) 返回字符串 <class 'int'>
内置的 isinstance() 函数可以用来查询变量所指的对象类型 # 会认为子类是父类的类型 isinstance(a, int) 返回True或False
1.3 删除已定义对象
a = 10
b = 20
c = 30
delete a
delete b,c
1.4 Python特殊的运算符
x ** y # **表示x的y次幂 2 ** 3 = 8 同理 x **=y 表示 x = x ** y
x // y # // 表示取整除 9 // 2 = 4 同理 x //=y 表示 x = x // y
1.5 Python的逻辑运算符
and 条件1 and 条件2
or 条件1 or 条件2
not not 条件
1.6 成员运算符
in x in y # x在y的序列中 返回True 否则返回False
not in x not in y # x不在y的序列中 返回True 否则返回False
1.7 比较两个对象是否一样
is x is y # 类比 id(x) == id(y) 相等则返回True
is not x is not y # 类比 id(x) != id(y) 不相等则返回True
二、 基本数据类型的介绍
2.1 Number
2.1.1 Number类型的细划分
// 不可改变的类型
Number又划分为四种类型：
（1） bool类型 True False
（2） int 整数
（3） float # 1.23 3E-2
（4） complex # 1 + 2j
2.1.2 PythonNumber类型的转化
int(x) 将x转换为一个整数。
float(x) 将x转换到一个浮点数。
complex(x) 将x转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。x 和 y 是数字表达式。
2.1.3 常见的一些数学函数 (可扩展)
max(x1, x2, ...)
min(x1, x2, ...)
pow(x, y)
sqrt(x)
2.2 String 详见Python基础语法1
2.3.1 String小说
var1 = 'Hello world'
var2 = var1[1:5] # 截取原字符串 var2 = ello
if ("H" in var1):
print("H 在变量var1中")
else:
print("H 不在变量var1中")
2.3.1 String字符串内建函数
count(str, beg= 0,end=len(string)) # 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
find(str, beg=0, end=len(string)) # 检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
join(seq) # 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
2.3 Tuple
2.3.1 元组的格式
tup1 = ('Google', 'Runoob', 1997, 2000) # 元组使用（），元素之间用，分割
tup2 = "a", "b", "c", "d" # 不需要括号也可以
tup3 = () # 空元组
tup4 = (a,) # 只有一个元素的元组后面必须要加上 ， 不然类型会被转义
总结： （1） 元组中各个元素的类型可能不一致
（2） 元组中各个元素必须用 ， 进行分割
（3） （）可以省略但不建议
（4） 元组只有一个元素的元组后面必须要加上 ， 不然类型会被转义
2.3.2 元组的增删查改
（1） 访问元组-------------通过index
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0]) # 输出 tup1[0]: Google
print ("tup2[1:5]: ", tup2[1:5]) # 输出 tup2[1:5]: (2, 3, 4, 5)
（2） 修改元组------------元组中的元素的值不允许修改，但可以对两个元组进行组合【元组的重组】
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# tup1[0] = 100 # 以下修改元组元素操作是非法的。
tup3 = tup1 + tup2
print (tup3)
（3） 删除元组------------删除整个元组对象【元组的元素不允许删除】
tup = ('Google', 'Runoob', 1997, 2000)
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup) # 报错
2.3.2 元组的基本操作
（1） 计算元组的元素的个数 len((1, 2, 3, 4)) # 结果4
（2） 元组的重组 a = (1, 2, 3) # c = a + b 最终c为(1, 2, 3, 4, 5, 6)
b = (4, 5, 6)
（3） 复制 ('Hi',)*4 # c = ('Hi',)*4 最终c为('Hi!', 'Hi!', 'Hi!', 'Hi!')
（4） 判断某个元素是否存在 3 in (1, 2, 3) # 返回True
（5） 元组的迭代
for x in (1, 2, 3):
print (x, end=" ") # 输出 1 2 3
（6） 元组的截取
tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
tup1 = tup[1:4] # 输出('Runoob', 'Taobao', 'Wiki')
tup2 = tup[1:] # 输出('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
tup3 = tup[-2] # 输出Weibo
2.3.3 元组的内置函数
len(tup)
min(tup)
max(tup)
将别的类型强转为tuple类型如 tuple(别的类型对象)
list = ['Google', 'Taobao', 'Runoob', 'Baidu']
tup = tuple(list)
print(type(tup))
2.4 List
2.4.1 List的介绍
list1 = ['Google', 'Runoob', 1997, 2000]
（1） 支持不同类型
（2） 支持索引 正向索引 0---》N 反向索引 -1---》-（N + 1）
（3） 支持切片
（4） 支持对list内部元素的更改
2.4.1 List的基本操作
list = ['Google', 'Runoob', "Zhihu", "Taobao", "Wiki"]
# 查看列表 直接打印对象即可
print(list)
# 修改列表
list[2] = 2001
list.append('Baidu')
print(list) # ['Google', 'Runoob', 2001, 'Taobao', 'Wiki', 'Baidu']
# 删除列表
（1）删除列表单个元素 del list[3]
（2）删除整个列表对象 del list
2.4.2 列表操作支持操作符
len([1, 2, 3, 4]) # 求列表长度 res = 4
[1, 2, 3] + [4, 5, 6] # 列表的组合 res = [1, 2, 3, 4, 5, 6]
['Hi!'] * 4 # 元素的复制 res = ['Hi!', 'Hi!', 'Hi!', 'Hi!']
3 in [1, 2, 3] # 元素是否存在于列表中 返回True
for x in [1, 2, 3]: print(x, end=" ") # 123 列表迭代
a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b)) # operator模块 支持两个List之间的比较
2.4.2 列表的内置函数
--------------------------------------------------------------------------------------------------------
len(list) # 列表长度
max(list)
min(list)
list(别的类型对象) # 将别的类型强转为list类型如 list(别的类型对象)
--------------------------------------------------------------------------------------------------------
list.append(x) # 追加单个x
list.extend(seq) # 追加一个seq的列表（包含多个元素的列表）
list.count(x) # 统计x在列表中出现的次数
list.index(x) # 计算x在列表中Index
list.insert(index, x) # 在列表index的位置插入x
list.pop([index = -1]) # 弹出列表中index位置的元素 默认是最后一个元素
list.remove(元素) # 直接移除某个元素（第一个匹配的）
list.reverse() # 反转列表元素
list.sort( key=None, reverse=False) # 对列表进行排序
list.clear() # 清空列表
list.copy() # 拷贝列表
2.5 Dictionay
2.5.1 字典介绍
tinydict2 = { 'abc': 123, 98.6: 37 }
（1） 支持不同类型的键值对， 键值对之间通过，进行分割
（2） key不能重复，且key不能被更改
（3） 不支持索引
（4） 空子典的创建方式
tinydict = {}
tinydict = dict()
2.5.2 字典的基本操作
(1) 访问字典
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print("tinydict['Name']: ", tinydict['Name']) # 访问单个val
print(tinydict) # 访问整个tinydict
(2) 修改字典--------增加或修改已有的键值对
tinydict['Age'] = 8 # 更新 Age的val
tinydict['School'] = "菜鸟教程" # 新增键值对
(3) 删除字典
del tinydict['Name'] # 删除键值对按key 'Name'
del tinydict # 删除字典对象
tinydict.clear() # 清空字典
2.5.3 字典的内置函数
len(tinydict) # 计算tinydict中的键值对
str(tinydict) # 将dictionary转化为str
type(tinydict) # 输出dictionary的类型 <class 'dict'>
key in dict # 判断key是否在dict中
dict.items() # 以列表返回一个视图对象 print ("Value : %s" % tinydict.items())
dict.keys() # dict中的所有key
dict.values() # dict中的所有val
dict.setdefault(key, default=None) # 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
dict.get(key, default=None) # 返回指定键的值，如果键不在字典中返回 default 设置的默认值
popitem() # 返回并删除字典中的最后一对键和值
pop(key) # 删除字典 key（键）所对应的值，返回被删除的值
dict.update(dict2) # 把字典dict2的键/值对更新到dict里
2.6 Set
2.6.1 集合的并集、交集、差集、对称差、子集
namelist1={'alia','sanb','lige'}
namelist2={'alia','bobu'}
（1） 并集 |
print(namelist1 | namelist2) #{'alia', 'sanb', 'bobu', 'lige'} 两个set加起来去重
print(namelist1.union(namelist2)) #{'alia', 'sanb', 'bobu', 'lige'}
（2） 交集 &
print(namelist1&namelist2) #{'alia'} 两个set都有的
print(namelist1.intersection(namelist2)) #{'alia'}
（3） 差集 -
print(namelist1 - namelist2) #{'sanb', 'lige'} set1中独有的
print(namelist1.difference(namelist2)) #{'sanb', 'lige'}
（4） 对称差集 ^
print(namelist1 ^ namelist2) #{'sanb', 'bobu', 'lige'} set1中独有 + set2中独有的
print(namelist1.symmetric_difference(namelist2)) #{'sanb', 'bobu', 'lige'}
（5） 子集 <
str1 = set("hello")
str2 = set("he")
print(str2 < str1) #True
print(str2.issubset(str1)) #True
2.6.2 集合的基本操作
集合创建的方式 （1） param = {val1, val2, ...} (2) param = set([1, 3, 5, 7])
集合的空集表示方式 set() 而非 {}， {}表示空dictionary
集合是【无序的】【不重复的】元素序列
------------------------------------------------
# 添加元素
thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook") # s.add(元素) 集合添加单个元素
thisset.update({1, 3}) # s.update(setseq) 集合添加多个元素
thisset.update([2, 4], [5, 6]) # s.update(setseq) 集合添加多个元素update方法支持参数类型可以是列表、集合、元组、字典等
------------------------------------------------
# 删除元素
thisset.remove("Taobao") # 从thisset中移除Taobao这个元素， 若Taobao不存在，则报error
thisset.discard("Taobao") # 从thisset中移除Taobao这个元素， 若Taobao不存在，不会报错
thisset.pop() # 从thisset中随机移除某个元素
------------------------------------------------
# 查看元素
print(thisset) # 直接打印该set集合即可
------------------------------------------------
2.6.3 集合的常见API
len(thisset)
thisset.clear()
x in thisset