数字类型
'''
1. 整型
a1 = 10
a2 = int(20)
2. 长整型(py2特有，py3废弃)
b1 = 12345678901234567890
b2 = long(100)
3. 浮点型
c1 = 3.14
c2 = float(5.12)
4. 复数类型
d = 2 + 3j
'''
'''
总结：
1. 只可以存放一个值：num = 1000
2. 为不可变类：num += 1
'''
代码实例:
# 整型int 长整型long 浮点型 复数
# a = 10 # int(10)
a = int(10)
print(a, type(a))
# py3不支持long
# a1 = long(10)
# print(a1, type(a1))
# py3用int表示所有整型(包括天文数字(不存在越界溢出))
# 原因：当数据过大，底层采用字符串存储
a2 = 12345678901234567890123456789012345678901234567890
print(a2, type(a2))
# 小数
b = float(3.14)
print(b, type(b))
# 复数：实数 + 虚数j
# c = 5 + 4j
c = complex(5, 4)
print(c, type(c))
# py2与py3的input区别
字符串类型
''' *****
1. 单行字符串
s1 = 'abc'
ss1 = "xyz"
2. 多行字符串
s2 = """first line
second line
last line"""
3. 字符串嵌套
i) 单、双、三引号直接可以相互嵌套
ii) 同类型引号直接嵌套需要转义：\' | \"
4. 索引取值
s4 = 'oldboy'
i) 正向取值从0开始：s4[0]
ii) 逆向取值从-1开始：s4[-1]
5. 切片(顾头不顾尾，切片有步长)
s5 = 'my love'
语法：[起始索引:结束索引:步长]
i) 步长省略，默认为1
ii) 起始索引省略，默认为从头开始
iii) 结束索引省略，默认到最后结束
了解：逆向取值，起始索引与步长为负值情况下
6. 长度
s6 = 'oldboy'
print(len(s6))
print(s6.__len__())
7. 成员运算
语法：in | not in：子字符串是否在父字符串中
'he' in 'hello'
8. 首尾去白
语法：strip()
' hello wolrd '.strip()
'===login success==='.strip('=')
9. 拆分
语法：split(拆分规则, 拆分次数)
'D:\\python36\\python3.exe'.split('\\', 1)
10.纯数字判断
语法：isdigit()
'18'.isdigit()
11. 循环(迭代)
s10 = 'hello wolrd'
count = 0
while count < len(s10):
print(s10[count])
count += 1
for s in s10:
print(s)
'''
'''
总结：
1. 只可以存放一个值：s = 'abc'
2. 为不可变类：s = 'xyz'
'''
''' ***
1. lstrip | rstrip：左 | 右 取留白
2. rsplit：从右开始拆分
3. lower | upper：全小 | 大写
4. startswith | endswith：以某某开头 | 结尾
5. format：格式化
'name:{}，age:{}'.format('Owen', 16)
'name:{0}，age:{1}'.format('Owen', 16)
'name:{name}，age:{age}'.format(name='Owen', age=16)
6. replace：替换
语法：replace(oldS, newS, count)
'''
''' *
1. find | rfind：查找子字符串索引，无结果返回-1
2. index | rindex：查找子字符串索引，无结果抛出异常
3. count：计算子字符串个数
4. center | ljust | rjust | zfill：按位填充
语法：center(所占位数, '填充符号')
5. expandtabs：规定\t所占空格数
6. captialize | title | swapcase：首字母大写 | 单词首字母大写 | 大小写反转
7. isdigit | isdecimal | isnumeric：数字判断
8. isalnum | isalpha：是否由字母数字组成 | 由字母组成
9. isidentifier：是否包含关键字
10. islower | isupper：是否全小 | 大写
11. isspace：是否是空白字符
12. istitle：是否为单词首字母大写格式
'''
'''
了解：字符串运算
'''
代码实例:
"""
# 1. lstrip | rstrip：左 | 右 去留白
s1 = " hello world "
print(s1.rstrip())
ss1 = "===hello world***"
print(ss1.rstrip("*"))
# 2. rsplit：从右开始拆分
s4 = "D:\\pathon36\\python3.exe"
s4_list = s4.rsplit('\\', 1)
print(s4_list)
# 3. lower | upper：全小 | 大写
print("AbCd".lower())
print("AbCd".upper())
# 4. startswith | endswith：以某某开头 | 结尾：返回值为bool类型
print("http://www.baidu.com".startswith('https://'))
print("http://www.baidu.com".endswith('com')) # 思考：自学正则：re
# 5. format：格式化
print('name:%s，age:%s' % ('owen', 18))
# 占位与实际数据要进行个数与位置的匹配
print('name:{}，age:{}'.format('Liuxx', 8))
# 指定位置要数据：{0}要0号位数据
print('name:{0}，age:{1}, name:{0}'.format('Linoo', 58))
# 指定名字要数据
print('name:{usr}，age:{age}, name:{usr}'.format(age=58, usr='Linoo'))
# 6. replace：替换
# 语法：replace(oldS, newS, count)
s6 = 'abcabcabc'
newS6 = s6.replace('a', 'A', 2)
print(newS6)
"""
了解部分：
# --------------------------------------------------------------------
# 1. find | rfind：查找子字符串索引，无结果返回-1
s1 = 'abcabc'
print(s1.rfind('ab')) # 返回第一次查询到的（目标字符串首位）正向索引
# 2. index | rindex：查找子字符串索引，无结果抛出异常
# print(s1.index('cb')) # 崩溃
# 3. count：计算子字符串个数
print(s1.count('abc'))
# 4. center | ljust | rjust | zfill：按位填充
# 语法：center(所占位数, '填充符号')
# 使用： 调用者.center(参数)
print("华丽分割线".center(30, '-'))
print("华丽分割线".ljust(30, '-'))
print("1240".zfill(5))
print("9010".zfill(5))
print("59000".zfill(5))
# 5. expandtabs：规定\t所占空格数
print('hello\tworld'.expandtabs(8))
# 6. captialize | title | swapcase：首字母大写 | 单词首字母大写 | 大小写反转
print("hello world".capitalize())
print("hello world".title())
print("hello WORLD".swapcase())
# 7. isdigit | isdecimal | isnumeric：数字判断
# s7 = b'123' # isdigit来判断是否可以转换为数字
print(b'123'.isdigit())
# 三个方法均有
print(u'123'.isdigit())
print(u'123'.isdecimal())
print(u'123'.isnumeric())
print('肆'.isdigit())
print('肆'.isdecimal())
print('肆'.isnumeric()) # 可以判断中文数字
print('Ⅳ'.isdigit())
print('Ⅳ'.isdecimal()) # 不用管
print('Ⅳ'.isnumeric()) # 可以判断罗马数字
# 8. isalnum | isalpha：是否由字母数字组成 | 由字母组成
print('abc123_'.isalnum())
print('abc'.isalpha())
# 9. isidentifier：是否为合法变量名
print('>>>', 'a_123'.isidentifier())
# 10. islower | isupper：是否全小 | 大写
print("aBc".islower())
# 11. isspace：是否是空白字符
print(" ".isspace())
# 12. istitle：是否为单词首字母大写格式
print("Hello World".istitle())
# list tuple dict set
# int = 10
# print(int)
# s = '10'
# print(int(s))
列表
''' *****
1. 声明：可以包含不同类型数据，可以嵌套，[]
2. 索引取值：支持正向反向
3. 切片(顾头不顾尾，切片有步长)
4. 长度
5. 成员运算
6. 增删改
list = [1, 2, 3, 4, 5]
增：append(obj) | insert(index, obj)
删：remove(obj) | del(list[index]) | pop(index)
改：list[index] = newObj
7. 循环
8. 反转
语法：reverse()
9. 排序
语法：sort(reverse=True)
'''
'''
总结：
1. 可以存放多个值：list = [1, 2, 3]
2. 为可变类型：list.append(4)
3. 有序存储：排列的索引取值
'''
''' ***
1. copy：复制
2. clear：清空
3. count：计算成员个数
4. extend：添加多个值(参数为可迭代对象)
5. index：查找索引
'''
'''
了解：列表的运算
'''
代码实例:
l1 = [1, 3.14, 5 + 4j, True, 'abc', [[1]]]
print(l1)
l2 = list([1, 3.14, 5 + 4j, True, 'abc', [[1]]])
print(l2)
l3 = list('abc')
print(l3)
# 二、字符串 <=> 列表
# 将字符串转换为列表: 字符串方法
l4 = 'hello world'.split(' ')
print(l4)
# 将列表转换为字符串: 字符串方法，调用方法的字符串为拼接字符串的依据
# 将列表中的所有数据，从前往后，安装拼接符进行拼接
newStr = '@'.join(l4) # hello@world
print(newStr)
# 三、切片
list3 = [1, 2, 3, 4, 5]
print(list3[1:-1:2]) # [2, 4]
# 四、增删改查
# 删除普通变量
# a = 10
# del a
# print(a)
# 增：append(obj) 在末尾添加对象
list4 = []
# print(id(list4))
list4.append(1)
list4.append(5)
list4.append(2)
print(list4)
# 插入
list4.insert(0, 10)
print(list4)
# print(id(list4))
# 删
# 删除指定索引
del list4[0]
print(list4)
# 删除指定对象
list4.remove(5)
print(list4)
# 改：
list4[0] = 10000
print(list4)
# 查
print(list4[1])
# 五、长度
list4.append(88888)
print(len(list4)) # list4: [10000, 2, 88888]
# 六、成员运算
print(2 in list4)
# 七、循环：迭代
list7 = [1, 3, 5, 7, 0]
for obj in list7:
print(obj, end=',')
# 需求：打印1,3,5,7,0
sss = ""
for obj in list7:
sss += str(obj) + ',' # obj是int类型，不能直接做字符串拼接，转化成字符串
print('>>>', sss[:-1])
# 翻转
a = [1, 3, 2]
a.reverse()
print(a)
# 排序: 前提：1.数据之间全部具有可比性；2：数据要统一类型
b = [1, 3, 2, 5, 4]
# b.sort()
# print(b)
# 倒序
# b.reverse()
# print(b)
b.sort(reverse=True)
print(b)
# ----------------------------------------------------
''' ***
1. copy：复制
2. clear：清空
3. count：计算成员个数
4. extend：添加多个值(参数为可迭代对象)
5. index：查找索引
'''
x = [1, 3, 5, 3]
y = x
print(x, id(x))
print(y, id(y))
z = x.copy()
print(z, id(z))
x[0] = 10000
print(x[0])
print(y[0])
print(z[0])
z.clear()
print(z)
# [10000, 3, 5, 3]
print(x.count(3)) # 2
list1 = []
list1.extend('abc')
print(list1)
list2 = ['abc', 'xyz']
list1.extend(list2)
print(list1)
'''
总结：
1. 列表中可以存放多个值
2. 列表为可变类型：id不变的情况下，可以发生值变化
3. 列表为有序存储结构：可以通过索引取值
'''
元组
'''
1. 声明：可以包含不同类型数据，可以嵌套，()
2. 索引取值：支持正向反向
'''
'''
总结：
1. 可以存放多个值：t = (1, 2, 3)
2. 为不可变类型
3. 有序存储：排列的索引取值
'''
代码实例
l1 = []
l2 = [1]
print(l1, l2)
# 元组：可以理解为，不可变的列表
# 1.元组的长度不可以变化
# 2.元组中的值可以变化，但是变化其实是存放了可变的数据类型，元组本质没有改变
# 一、定义
t1 = (1, 2, 3, 4, 5)
print(t1)
t2 = tuple((1, 2, 3, 4, 5))
print(t2)
# 空元组
t3 = ()
print(t3)
t4 = tuple()
print(t4)
# 含义一个值的元组
t5 = (1, )
print(t5)
t6 = tuple((1, ))
print(t6)
t7 = (5, 3, 2, 1, 6)
print(t7[0])
print(t7[-1])
# 不可改变: 但一个列表需要对其进行限制，让其无法发生改变，可以将其转化为元组
list1 = [1, 2, 3]
tuple1 = tuple(list1)
print(tuple1)
# 如果重新想更改，可以转化回去
list2 = list(tuple1)
print(list2)
# 注：元组中存放了可变类型数据，可以发生形式上的值改变，本质值未发生改变
t1 = (1, 'abc', [10, 'xyz'])
print(t1, id(t1))
# 成立：元组中列表值发生改变，列表自身id不变，所以元组中的中未发生改变
t1[2][1] = 'XYZ'
print(t1, id(t1))
# t1[1] = 'ABC' # 报错：元组中的值不能发生变化(id需要改变)
# print(t1, id(t1))
'''
总结：
1. 可以存放多个值：t = (1, 2, 3)
2. 为不可变类型
3. 有序存储：按索引取值
'''
字典：
'''
1. 声明：key为不可变类型数据，value可以为任意类型，{}
d1 = {'name': 'Owen'}
d2 = dict(name='Owen')
d3 = dict([('name','Owen')])
d4 = {}.fromkeys(['name'], None)
2. 增删改查
增：d2['newKey'] = value
删：pop('key', defalutValue)
改：d2['key'] = newValue
查：d1['key']
了解：popitem()：从末尾开始删除，返回(key, value)
3. 长度：len
4. 成员运算：in | not in
5. 循环
i) 直接for循环
ii) keys()
iii) values()
iv) items()
6. 默认值取值：get
语法：get(key, defalutValue)
7. 更新
{'name': 'owen'}.update({'name': 'Owen', age: 18})
8. 设置默认
语法：setdefault(key, defalutValue)
'''
'''
总结：
1. 可以存放多个值：dic = {'name': 'Owen', age: 18}
2. 为不可变类型
3. 无序存储：安装key取值
'''
代码实例
# dic1 = {'name': 'Owen', 'age': 18}
dic1 = {'name': None, 'age': None}
print(dic1)
dic2 = dict([('name', 'Egon'), ('age', 58)])
print(dic2)
dic3 = dict(name='Zero', age=18)
print(dic3)
dic4 = {}.fromkeys(['name', 'age'], None)
print(dic4)
# 二、get：有默认值的取值
dic = {'name': 'Owen', 'age': 18}
print(dic.get('name', "该key不存在")) # 存在就会打印实际的值
print(dic.get('name123', "该key不存在")) # 不存在，未规定默认值，打印None，规定就打印规定的默认值
# 三、字典的key可以为所以不可变类型，value可以为任意类型
# 原因：字典的key是取值的唯一途径，所以一定要保证唯一性(一旦确定值，就不会再更改)
d1 = {}.fromkeys([1, 3.14, (1,), '123', True], None)
print(d1)
# 三、增删改查
dic = {'name': 'Hou', 'age': 3}
print(dic)
# 增
dic['gender'] = '哇塞'
print(dic)
# 删
del dic['age']
print(dic)
# 改
dic['name'] = 'DaHou'
print(dic)
# 查
print(dic['name'])
# 总结：
# 1. 字典可以存放多个值
# 2. 字典为可变类型
# 3. 字典是无序存储，用key进行取值
# 多值更新
dic = {'name': 'Engo', 'salary': 100}
dic.update({'name': "Egon", 'age': 58, 'gender': '未知'})
print(dic)
# 类列表类型，不能直接通过index取值，但可以被for循环迭代取值
print(dic.keys())
print(dic.values())
print(dic.items())
for k in dic.keys():
print(k, ":", dic[k])
print('------------------------------------')
for v in dic.values():
print(v)
print('------------------------------------')
for k, v in dic.items(): # *****
print(k, v)
a, b, c = [1, 2, 3]
print(c)
a, b, _ = (1, 2, 3)
print(a)
# 嵌套: JSON
dic = {
'students': [
{
'name': 'Bob',
'id': 1,
'gender': '男'
},
{
'name': 'Tom',
'id': 2,
'gender': '女'
}
],
'teachers': []
}
stus = dic['students'] # list
tom_stu = stus[1] # dic
name = tom_stu['name']
print(name)
print(dic['students'][1]['name'])
print('======================')
for k, v in dic.items():
# 只遍历学生
if k == 'students':
for stu in v:
for s_k, s_v in stu.items():
print(s_k, ":", s_v)
print('--------------')
if k == 'teachers':
pass
集合
'''
1. 声明：
s = {1, 2, 3, 4, 5}
2. 集合运算
&交集 | |合集 | ^对称差集 | -差集 | 比较
'''
代码实例：
# 无序、无key、无索引集合
# set特定：存放数据具有唯一性:去重
# 应用场景：处理大量有重复信息的数据，对其去重，如果需要取值，将其转化为list
s = set()
print(type(s), s)
# 增
s.add('a')
s.add('b')
s.add('a')
s.add('b')
s.add('c')
print(s)
# 取值, 遍历(set也提供了自身遍历)
ls = list(s)
print(ls)
# 遍历
for v in s:
print(v)
# 多个关系set完成关系运算
py = {'a', 'b', 'c', 'egon'}
ln = {'x', 'y', 'z', 'egon'}
# 只报python, 反过来Linux
res = py - ln
print(res)
res = ln.difference(py)
print(res)
# 两个都报了的
res = py & ln
res = py.intersection(ln)
print(res)
# 只报一门
res = py ^ ln
res = py.symmetric_difference(ln)
print(res)
# 报名的学生
res = py | ln
res = py.union(ln)
print(res)
