数据类型

常见的基本数据类型:
    1. int 整数
    2. bool 布尔. 判断. if  while
    3. str 字符串, 一般放小量的数据.
    4. list 列表. 可以存放大量的数据
    5. dict 字典, 以key:value的形式存储数据
    6. set 集合(数学)
    7. tuple 元组 不可变

• int

　　整数:可以 +、-、*、/、//、%、**运算
　　bit_length() 一个数的二进制长度

• bool

　　类型转换
　　　　字符串转换成整数 int(str)
　　　　整数转换换字符串 str(int)
　　　　结论: 想转化成xxx数据类型    xxx(目标)
　　　　结论2: True => 1  False => 0
　　　　结论3 , 可以当做False来用的数据: 0, "", [], (),{}, None 所有的空都是False
　　　　所有的空的东西都是False

• 字符串　　字符:单一的文字符
  　　字符串:有序的字符序列
  　　字符串由' " ''' """ 括起来的内容叫字符串
  　　索引
  　　　　一排数字,反应第某个位置的字符 ,索引的下标从0开始,使用[]来获取数据
  　　切片:[start:end:step] 顾头不顾腚 最后一个取不到
  　　　　　　开始:结尾:步长
  

s = '刘德华很帅但是张国荣更'
print(s[2])
print(s[11])
print(s[-1]) # 倒数第一
print(s[-4]+s[-3]+s[-2])

　　切片:[start:end:step]  顾头不顾腚 最后一个取不到
　　　　　　开始:结尾:步长   step:步长.如果是+从左往右. 如果是-从右往左  每n个取1个

s = '刘德华很帅但是张国荣更'
#切片 s[start: end] 顾头不顾尾
print(s[7:10])
print(s[0:3])
print(s[-4:-1])
print(s[-1:-4]) # 默认的方向是从左往右切.
#从德开始切. 切到结尾
print(s[1:]) # 末尾
print(s[:4]) # 开头
print(s[:])


s = "我要开始玩幺蛾子了你们怕不怕我很怕"
print(s[1:5])
print(s[5:1:-1])
#第三个参数是步长
print(s[1:5:3])
print(s[4:8:2])

s = "0123456789"
print(s[::2]) # 02468
print(s[-1:-6:-2])
print(s[::-3])
print(s[::-1])

常用操作方法:

　　　1. upper() 转化成大写. 忽略大小写的时候  lower小写
　　　2. strip() 去掉左右两端空白   用户输入的内容都要去空白
　　　3. replace(old, new) 字符串替换
　　　4. split() 切割  结果是list
　　　5. startswith() 判断是否以xxx开头    endseith  结尾
　　　6. find() 查找
　　　7. isdigit() 判断是否是数字组成
　　　8. len()  求长度. 内置函数

　　1.大小写转来转去

s = "abcd is not a good man! Mn is a good man"
s1 = s.capitalize()  # 首字母大写
print(s1)
s2 = s.lower()
s3 = s1.upper() # 转化成大写字母. 要求记住. 使用场景: 忽略大小写的时候需要
print(s2)
print(s3)


s = "abcd is not a good man! Mn is a good man"
s1 = s.swapcase()  # 大小写互换
print(s1)

s2 = "БBß" # 俄美德
print(s2)
print(s2.lower())
print(s2.casefold()) # 都转化成小写. 支持的文字比lower多


s = "class app_le banana ora1nge pear "
s1 = s.title() # 标题.把单词的首字母大写
print(s1)

　　2.切来切去

s = "天然"
s1 = s.center(4,"*") # 把字符串拉长成4个单位 用*扩充
print(s1)

s = " 	       你好啊. 我叫赛利亚       "
print(s)
s1 = s.strip() # 去掉空白
print(s1)



#模拟登陆
#用户输入的内容是无法保证合法的. 需要进行处理和判断
username = input("请输入用户名:").strip()
password = input("请输入密码:").strip()
if username == "alex" and password == "123":
    print("成功")
else:
    print("失败")


s = "你好啊跟你好"
print(s.strip("好"))



s = "abs_wasd_rty_thon_evaj_eggon"
# s1 = s.replace("rty", "try")
s1 = s.replace("i", "SB", 2)
print(s1)

s = "abs_wasd_rty_thon_evaj_eggon"
lst = s.split("_") # 刀有多宽 就要损失掉多少
print(lst)



s = "周润发周星驰周笔畅周杰伦"
lst = s.split("周润发周星驰周笔畅周杰伦")  # 切割的内容在边上. 会出现空字符串
print(lst)

　3.格式化输出

# 格式化输出
print("我叫%s, 我今年%d岁了, 我喜欢干%s" % ("abs", 18, "python"))
print("我叫{}, 我今年{}岁了, 我喜欢干{}".format("abs", 18, "python"))
print("我叫{0}, 我今年{1}岁了, 我喜欢干{2}".format("abs", 18, "python"))
print("我叫{name}, 我今年{age}岁了, 我喜欢干{hobby}".format(name="sbs", age=18, hobby="python"))

4.查找

s = "今天的内容非常简单.你们信吗? 作业也很容易. 就是整理不太好"
print(s.startswith("太好了"))
print(s.endswith("太好了"))
             

s = "胡辣汤炸鸡啤酒烤鸭酱肘锅包肉炸鸡炸鸡炸鸡"
print(s.count("炸鸡")) # 计数
print(s.find("疙瘩汤")) # 如果找不到返回-1  用这个
print(s.index("疙瘩汤")) # 如果找不到报错.

5.条件判断

s = "一二壹贰叁肆萬两"
print(s.isnumeric())

# 条件判断
s14 = "123.16"
s15 = "abc"
s16 = "_abc!@"
# 是否由字⺟和数字组成
print(s14.isalnum())
print(s15.isalnum())
print(s16.isalnum())
# 是否由字⺟组成
print(s14.isalpha())
print(s15.isalpha())
print(s16.isalpha())
# 是否由数字组成, 不包括⼩数点
print(s14.isdigit())
print(s14.isdecimal())
print(s14.isnumeric()) # 这个⽐较⽜B. 中⽂都识别.
print(s15.isdigit())
print(s16.isdigit())

6.计算字符串的长度

s = "我是上帝, 你也是上帝"
print(len(s)) # 内置函数len(字符串) 返回给你字符串的长度

for循环
我们可以使⽤for循环来便利(获取)字符串中的每⼀个字符 
语法: 
　　for 变量 in 可迭代对象: 
　　　　pass 
　　　　可迭代对象: 可以⼀个⼀个往外取值的对象

s = "朱元璋朱棣"
count = 0
while count < len(s):
        print(s[coount])
        count += 1

s = "朱元璋朱棣朱建峰"
#for循环
#for变量 in 可迭代对象:
#把可迭代对象中的每一个元素 ,分别赋值给前面的变量,可以方便可迭代对象的遍历
for c in s:
    print(s)


了解一下  报错
for i in 10:
    print(i)

TypeError: 'int' object is not iterable
错误类型:整数对象不能迭代

• list

　　什么是列表
　　　　能装东西的东西,列表中装的数据是没有限制的,32位 python可以存放: 536870912个元素, 
64位可以存放: 1152921504606846975个元素.大小基本上是够用的
　　列表使用[]来表示. 在列表中每个元素元素之间用逗号隔开

　　索引
　　　　索引和切片参照字符串
　　　　一排数字,反应第某个位置的字符 ,索引的下标从0开始,使用[]来获取数据
　　　　切片:[start:end:step] 顾头不顾腚 最后一个取不到
　　　　　　 开始:结尾:步长

lst = ["上海滩","西游记","家有儿女","奥特曼","包青天","少年包青天"]
print(lst[3])
print(lst[-4])
print(lst[-1][1:3])

      切片:[start:end:step] 顾头不顾腚 最后一个取不到
　　　　开始:结尾:步长 step:步长.如果是+从左往右. 如果是-从右往左 每n个取1个

# lst = ["上海滩","西游记","家有儿女","奥特曼","包青天","少年包青天"]
#  切片
# print(lst[1:3]) # 切片出来的是列表.
# print(lst[1:5:2])
# print(lst[-1:-4:-2])

增删改查

　　新增:

　　　　1.append() 追加

　　　　2.insert() 　插入　　　

　　　　3.extend()　迭代增加　

# lst = []
# lst.append("周杰伦") # 追加 在最后添加, 效率比较高
# lst.append("周芷若")
# lst.append("周公瑾")
# print(lst)

# lst = ["刘德华", "渣渣辉", "古天乐", "陈小春"]
# lst.insert(2,"马德华")  # 插入, 可能会导致元素移动
# print(lst)

# lst = ["刘昊然", "张一山", "徐峥", "黄渤"]
# lst.extend(["刘能", "赵四", "广坤"])
# print(lst)

　　删除:

　　　　1.remove()   指定元素

　　　　2.pop()　　　弹　

　　　　3.clear()　　　清空

　　　　4.del 　　　　

# 删除 pop, remove, clear, del
# lst = ["刘能", "广坤", "皮长山", "大脚"]

# lst.pop(2) # 可以指定元素删除(索引)
# print(lst)
# s1 = lst.pop() # 默认弹出最后一个
# print(s1)
# s2 = lst.pop()
# print(s2)
# print(lst)

# lst.remove("广坤")
# lst.remove("大脚")
# print(lst)

# lst = ["语文", "数学", "地理", "历史", "英语", "化学"]

# lst.clear() # 清空

# 可以切片删除
# del lst[2]
# del lst[0]
# del lst[::2]
# print(lst)

　　　修改:

　　　　索引修改

# lst = ["功夫", "大话西游", "少林寺", "无间道", "战狼", "战狼2"]
# # lst[2] = "西西里的美丽传说"
# lst[-3] = "新世界"
# lst[1:3] = ["一步之遥"]
# lst[1:5:2] = ["胡辣汤", "烩面"] # 注意如果步长不是1. 那么元素的个数要匹配
# print(lst)

　　　查询:

　　　for el in list:

　　　　　print(el)

　　

# 列表是一个可迭代对象. 可以使用for循环
# for el in list:
#     print(el)

相关操作:

lst = ["马化腾", "马云", "刘强东", "周鸿祎", "李彦宏", "马云", "马云"]
print(lst.count("马云"))    #出现几次

lst = [1.,15,55,54,5,9,64,4,6]
lst.sort()   #正序
lst.sort(reverse=True)  倒序排序

lst.reverse()  翻转


print(len(lst))   长度

嵌套

　　

　　元组和列表都可以进行嵌套

# lst = ["周润发", "周星驰", "周笔畅", "周公瑾", ["九品芝麻官", ["吴孟达", "ads", "林雪"],"算死草", "赌侠", "赌圣", "整蛊专家"]]
#
# lst[4][1][1] = lst[4][1][1].capitalize()
# print(lst)

• 元组

　　不可变的列表,只读列表,由小括号()表示.元素与元素之间用逗号隔开,数据类型没有限制

　　如果是空元组:tuple()

　　一个元素(1,)

# 清朝皇帝 (努尔哈赤, 皇太极, 顺治, 康熙, 雍正, 乾隆)  这些是不可变的  怎么都不会变的

# huang = ("努尔哈赤", "皇太极", "顺治", "康熙", "雍正", "乾隆", "嘉庆", "道光", "光绪", "咸丰")
# # huang[1] = "朱元璋" # 报错 'tuple' object does not support item assignment
# print(huang)

# 小括号在计算机里还表示算数优先级
# print((8+3)*7)

# tu = (1,) # 加了逗号, 就是元组了
# tu = ("哈哈","呵呵","嘿嘿",)
# print(type(tu))8
# lst = list()  # []
# tu = tuple()  # 空元组

# 元组也有索引和切片 和列表一样和字符串也一样
# tu = ("iphone", "nokia", "砸核桃", "Lenovo", "HTC", "Honor")
# print(tu[-1])
# print(tu[1:3])
# print(tu[1:5:2])

# 不可变指的是第一层元素不可变, 第二层取决于你的数据类型
# tu = (1, 2, 5, ["胡辣汤", "滋滋冒油的大猪蹄子", "酱猪肘", "香喷喷的米饭", "脆皮炸鸡"])
# tu[3].append("锅包肉")
# print(tu)

# tu = ("孙悟空", "白骨精", "哪吒", "二师兄", "妲己")
#
# for el in tu:  # element 元素
#     print(el)

range

　　

#range()
 for i in range(100):   0-99
        print(i)

for i in range(3,8):   34567   没有8     
    print(i)

for i in range(5,10,2): 从5到10 步长是2
    print(i)


# range(边界) 从0到这个边界
# range(start, end) 从start到end结束. 不能到end
# range(start, end, step) 从start到end. 步长是step


lst = ["张无忌", "张三丰", "张翠山", "张一山", "张磊", "张伟", "张角"]
for i in lst:
    print(i)                没有索引


for i in  range(len(lst)):
    print(lst[i])              有索引

tu = ("首页", "登录", "注册", "购物", "退出")
for i in range(len(tu)):
        print(i,tu[i])

遍历列表的时候可以使用range

　　for i in range(len(list))

　　　　print(i,list[i])

• 字典

什么是字典　

　　 字典(dict)是python中唯⼀的⼀个映射类型.他是以{ }括起来的键值对组成. 在dict中key是唯⼀的. 在保存的时候, 根据key来计算出⼀个内存地址. 然后将key-value保存在这个地址中.这种算法被称为hash算法, 所以, 切记, 在dict中存储的key-value中的key'必须是可hash的,如果你搞不懂什么是可哈希, 暂时可以这样记, 可以改变的都是不可哈希的,那么可哈希就意味着不可变. 这个是为了能准确的计算内存地址⽽规定的. 

　　已知的可哈希(不可变)的数据类型:int ,str,tuple,bool

　　不可哈希(可变)的数据类型:list,dict,set

语法 :

　　 {key1: value1, key2: value2....}

注意: key必须是不可变(可哈希)的. value没有要求.可以保存任意类型的数据

# 合法 
dic = {123: 456, True: 999, "id": 1, "name": 'sylar',"age": 18, "stu": ['帅哥', '美女'], (1, 2, 3): '麻花藤'} 
print(dic[123])
print(dic[True])
print(dic['id']) 
print(dic['stu']) 
print(dic[(1, 2, 3)]) 
# 不合法 
# dic = {[1, 2, 3]: '周杰伦'}   # list是可变的. 不不能作为key 
# dic = {{1: 2}: "哈哈哈"}     # dict是可变的. 不不能作为key 
dic = {{1, 2, 3}: '呵呵呵'}    # set是可变的, 不不能作为key

 dict保存的数据不是按照我们添加进去的顺序保存的. 是按照hash表的顺序保存的. ⽽而hash表 不是连续的. 所以不能进行切片工作. 它只能通过key来获取dict中的数据

字典的增删改查

增加

dict[新key] = value
dict.setdefault()

dic = {}
dic['name'] = '周润发' # 如果dict中没有出现这个key, 就会新增⼀个key-value的组
合进dict
dic['age'] = 18
print(dic)
# 如果dict中没有出现过这个key-value. 可以通过setdefault设置默认值
dic.setdefault('李嘉诚') # 也可以往⾥⾯设置值.
dic.setdefault("李嘉诚", "房地产") # 如果dict中已经存在了. 那么setdefault将不会
起作⽤
print(dic)

# dic = {}
# # 徐峥：人在囧途
# dic['徐峥'] = "人在囧途" # 直接用key往里面存数据即可
# dic['黄渤'] = "疯狂的石头"
# dic["王宝强"] = "天下无贼"
# dic["王宝强"] = "士兵突击" # 如果key已经存在。 那么会替换掉原来的value, 修改
#
# dic.setdefault("黄秋生")
# dic.setdefault("黄秋生", "无间道")    # 如果存在了key， 不会执行新增
#
# print(dic)

删除

pop(key)
popitem()
clear()
del dict[key]

dic = {"黄日华": "天龙八部", "吕颂贤": "笑傲江湖", "苏有朋": "倚天屠龙记", "六小龄童": "西游记"}
# dic.pop("吕颂贤") # 指定key删除
# dic.popitem()  # 随机删除
# del dic["黄日华"]  # 删除
# dic.clear() # 清空字典

print(dic)

修改

dic[key] = 新值
update()
查询

1. 用key直接查询 dict[key]
2. get(key, 如果key不存在返回的数据)
3. setdefault() 1. 执行新增流程. 2. 查询结果

dic = {"刘能": "王小利", "赵四": "刘晓光", "王木生": "范伟", "谢大脚": "于月仙", "李大国": "小鬼"}
# dic['王木生'] = "刘伟"
dic2 = {"刘能": "大阳哥", "赵四": "github", "王木生": "汪峰", "谢大脚": "冯提莫", "王大拿": "金老板"}
dic.update(dic2)
print(dic)

# 查询
dic = {'刘能': '大阳哥', '赵四': 'github', '王木生': '汪峰', '谢大脚': '冯提莫', '李大国': '小鬼', '王大拿': '金老板'}
# 1. 最直观。 直接用key
print(dic['周杰伦'])  # 当这个key不存在的时候会报错
# 2. get方法
print(dic.get("谢大脚", "周杰伦不在这里"))  # 没有key. 返回None
# 3. setdefault()  1. 新增(先看有没有key， 如果有就过， 如果没有，执行新增) 2.根据key把值返回
dic = {}
dic["盖伦"] = "德玛西亚之力"
value = dic.setdefault("菲奥娜", "无双剑姬")  # 新增
value2 = dic.setdefault("盖伦", "刘伟")  # 由于已经存在了key。 所以新增不执行。 直接查询结果
value3 = dic.setdefault("薇恩", "坑")

print(value3)
print(dic)

相关操作

dic = {"汪峰": "大陆音乐半壁江山", "周杰伦": "亚洲音乐天王", "罗志祥": "亚洲舞王"}

# 对字典的遍历
# print(dic.keys())   # dict_keys(['汪峰', '周杰伦', '罗志祥']) 像列表但不是列表
# for key in dic.keys():
#     print(key)  # 拿到key
#     print(dic[key]) # 拿到value

# print(dic.values())
# for value in dic.values():
#     print(value)


# 也可以遍历字典
# [('汪峰', '大陆音乐半壁江山'), ('周杰伦', '亚洲音乐天王'), ('罗志祥', '亚洲舞王')]
# print(dic.items())  # 拿到的是key和value
for k, v in dic.items(): # 当需要遍历字典. 在操作中涉及到key和value的时候.
    print(k) # 元组
    print(v)


# 字典本身是一个可迭代对象,可以直接进行for循环
for el in dic:  # 直接拿到key
    print(el)
    print(dic[el])

# 前面的变量的个数和后面解包的个数一致
# a, b = (10, 20) # 解构, 解包
# print(a)
# print(b)

字典的嵌套

wf = {
    "name": "汪峰",
    "age": 48,
    "成名曲": "春天里",
    "wife": {
        "name": "章子怡",
        "age": 39,
        "工作": "演员"
    },
    "children":[
        {"num": "001", "name": "汪一", "hobby": "唱歌"},
        {"num": "002", "name": "汪二", "hobby": "演戏"} # wf['children'][1]['name']
    ]
}

# wf['wife']['age'] = wf['wife']['age'] + 10
# print(wf)