python-数据类型（上）：数字、布尔值、字符串、字典

变量是用来保存临时数据的

在python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，系统会自动辨别。可以使用type（变量的名字），来查看变量的类型。

查看数据类型：type（2**32）

内置函数help
如果查看一个类的所有方法
首先要确定他的类型 -> type(数值) <class "类型">
help(类型)
如果查看这个类型的指定的方法
help(类型.方法名)

数字：

int（有符号整形）：
在32位机器上，整数的位数是32位，取值范围为-2**31～2**31-1；
在64位机器上，整数的位数是64位，取值范围为-2**63～2**63-1
long（长整形，也可以代表八进制和十六进制）：
python的长整数没有指定位宽
python3里只有整型的概念，没有长整型。如果整数发生溢出，python会自动将整数数据转换为长整数
float（浮点型）：
3.23，52.3E-4
complex（复数）：-5+4j，j是虚数

布尔值：

True或False：真或假，1或0

字符串：

字符串其实就是一个有序的字符序列(顺序是不可以改变的)

# python中定义一个字符串 无论是单引号 还是双引号 是等价的
name = "hello"
name1 = 'hello'
if name == name1:
    print("name 和 name1是等价的")

定义一个空的字符串 '' 或者 "" 或者 str()
空字符串 代表的就是 字符串中没有一个字符

name = str()
print(type(name))  #<class 'str'>
l = len(name)
print("name的字符个数:%d" % l)   #值为0

print("哈喽
你好
世界")   # 
:换行
# 保留其文本格式 可以使用三引号(" 或者 ')
my_str ='''哈喽你好你好你好你好你好你好
你好世界世界世界世界
世界世界世界世界世界
哈喽你好你好你好你好你好你好
你好世界世界世界世界
世界世界世界世界世界'''
print(len(my_str))   #
也是一个字符长度

my_str = "hello"
# 得到e这个字符 并打印(程序中 是从0开始) -> 下标索引
# 传入一个正常的下标索引
# 如果从左到右开始索引是0, 1, 2, 3....
ret = my_str[1]
print(ret)
# 从右到左开始的索引是-1, -2, -3, ....
ret = my_str[-4]
print(ret)
# 一定要保证字符串的下标索引是存在的

# 利用while 打印出字符串中的每个字符
# 定义一个变量
index = 0
l = len(my_str)   # 定义一个变量记录字符串的长度
while index < l:
    ret = my_str[index]
    print(ret)
    index += 1

# 切片的语法：[起始:结束(开区间):步长]
# 字符串是不可变的(改的都是复制版的)
a = "abcdef"
# 'abc' -> a[0:3]   或者  a[:3]
# 如果是从头部开始 0可以省略
ret1 = a[:3]
print(ret1)
# 验证字符串是不可变的
print(a)
 # 'ace'  a[:5:2]  或者  a[0:5:2] 或者 a[::2]
 #默认步长是1
ret2 = a[::2]
print(ret2)
ret3 = a[1:4:2]  # 'bd'
ret4 = a[::-2]  # 'fdb'
ret5 = a[-1:-4:-2]  # 'fd'

mystr = "my 	name is {name} and i am {age} old" #	代表tab键
# <1>find
# mystr.find(str, start=0, end=len(mystr))  检测 str 是否包含在 mystr中，如果是返回开始的索引值，否则返回-1
# 获取对应字符串的下标索引
print(mystr.find("name"))  # 字符串中name的索引，结果：4
# <2>index
# mystr.index(str, start=0, end=len(mystr))  跟find()方法一样，只不过如果str不在 mystr中会报一个异常.
print(mystr.index("name"))  # 字符串中name的索引，结果：4
# <3>count
# mystr.count(str, start=0, end=len(mystr))  返回 str在start和end之间 在 mystr里面出现的次数
print(mystr.count("a"))  # a的数量,结果：5
# <4>replace
# mystr.replace(str1, str2,  mystr.count(str1))  把 mystr 中的 str1 替换成 str2,如果 count 指定，则替换不超过 count 次.
print(mystr.replace("a", "w"))  # 替换，结果：my     nwme is {nwme} wnd i wm {wge} old
print(mystr.replace("a", "w", 1))  # 替换1个，结果：my     nwme is {name} and i am {age} old
# 5>split
# mystr.split(str=" ", 2)  以 str 为分隔符切片 mystr，如果 maxsplit有指定值，则仅分隔 maxsplit 个子字符串
print(mystr.split())  # 按空格分，结果：['my', 'name', 'is', '{name}', 'and', 'i', 'am', '{age}', 'old']
print(mystr.split('am'))  # 按am分，结果：['my 	n', 'e is {n', 'e} and i ', ' {age} old']
print(mystr.split('am', 2))  # 按am分2个，结果：['my 	n', 'e is {n', 'e} and i am {age} old']
print('1+2+3+4'.split('+'))  # 结果：['1', '2', '3', '4']
print('1+2
+3+4'.splitlines())  # 按换行来分，结果：['1+2', '+3+4']
# <6>capitalize
# mystr.capitalize() 把字符串的第一个字符大写
print(mystr.capitalize())  # 首字母大写，结果：My     name is {name} and i am {age} old
# <7>title
# 把字符串的每个单词首字母大写
print(mystr.title())  # 结果：My     Name Is {Name} And I Am {Age} Old
print('My Name Is '.istitle())  # 判断每个首字母是否大写，结果：True
# <8>startswith
# mystr.startswith(hello)  检查字符串是否是以 hello 开头, 是则返回 True，否则返回 False
print(mystr.startswith("my"))  # 结果：True
# <9>endswith
# mystr.endswith(obj)  检查字符串是否以obj结束，如果是返回True,否则返回 False.
print(mystr.endswith("old"))  # 判断一段字符串以什么结尾，结果：True
# <10>lower
# mystr.lower()  转换 mystr 中所有大写字符为小写
print(mystr.lower())  # 变小写，结果：my     name is {name} and i am {age} old
# <11>upper
# mystr.upper()  转换 mystr 中的小写字母为大写
print(mystr.upper()) #变大写，结果：MY     NAME IS {NAME} AND I AM {AGE} OLD
# <12>ljust
# mystr.ljust(width)   返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
print(mystr.ljust(50)) #长度50，不够后面用空格补上
print(mystr.ljust(50,'*')) #长度50，不够后面用*补上。结果：my     name is {name} and i am {age} old*************
# <13>rjust
# mystr.rjust(width)   返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
print(mystr.rjust(50,'-')) #长度50，不够前面用-补上。结果：-------------my     name is {name} and i am {age} old
# <14>center
# mystr.center(width)  返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
print(mystr.center(50,"-")) #打印50个字符，不够的用"-"补上，mystr放中间。结果：------my     name is {name} and i am {age} old-------
# <15>lstrip
# mystr.lstrip()  删除 mystr 左边的空白字符(无论是空格 还是
 或者是	)
print('
Alex
'.lstrip())
print('2222abcd33333'.lstrip("2"))  # 结果：abcd33333
# <16>rstrip
# mystr.rstrip()   删除 mystr 字符串末尾的空白字符
print('
Alex
'.rstrip())  # 去掉右边的空格和回车
print('   2222abcd33333'.rstrip("3"))  # 结果：   2222abcd
# <17>strip
# 删除mystr字符串两端的空白字符
print(' Alex
'.strip())  # 去掉左边和右边的空格和回车，结果：Alex
# <18>rfind
# mystr.rfind(str, start=0,end=len(mystr) )  类似于 find()函数，不过是从右边开始查找.
print("abcbdf".find("b"))  # 从左侧到右侧查找，结果：1
print("abcbdf".rfind("b"))  # 找到最后面那个值的下标，结果：3
print("abcbdf".rfind("e"))  # 查不到结果为-1
# <19>rindex
# mystr.rindex( str, start=0,end=len(mystr))  类似于 index()，不过是从右边开始. 查不到异常
# <20>partition 开发中使用
# mystr.partition(str)  把mystr以str分割成三部分,str前，str和str后
print("acbdf".partition("c"))  # 结果：('a', 'c', 'bdf')
# <21>rpartition
# mystr.rpartition(str)  类似于 partition()函数,不过是从右边开始.
print("acbdf".rpartition("c"))  # 结果：('a', 'c', 'bdf')
# <22>splitlines
# mystr.splitlines()   按照行分隔，返回一个包含各行作为元素的列表
print('abc
de
f'.splitlines())  # 结果：['abc', 'de', 'f']
# <23>isalpha
# mystr.isalpha()   如果 mystr 所有字符都是字母 则返回 True,否则返回 False
print(mystr.isalpha())  # 结果：False
# <24>isdigit
# mystr.isdigit()  如果 mystr 只包含数字则返回 True 否则返回 False.
print('12'.isdigit()) #是否是整数，结果：True
# <25>isalnum
# mystr.isalnum()   如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False
print(mystr.isalnum())  # 结果：False
# <26>isspace
# mystr.isspace()  如果 mystr 中只包含空格，则返回 True，否则返回 False.
print(' '.isspace()) #是不是空格，结果：True
# <27>join
# mystr.join(str)  mystr 中每个元素后面插入str,构造出一个新的字符串
my_list = ["1", "x", "hello"]  # 定义一个变量 记录列表
print("00".join(my_list))  # 结果：100x00hello
print('+'.join(['1','2','3']))  # 结果：1+2+3

name = "my 	name is {name} and i am {age} old" #	代表tab键

print(name.expandtabs(tabsize=30)) #把tab键转成多少个空格
print(name[name.find("name"):]) #字符串的切片
print(name.format(name = 'alex',age = 25))
print(name.format_map({'name': 'alex','age': 25}))
print('12'.isdecimal()) #是否是十进制
print('_1A'.isidentifier()) #判断是不是一个合法的标识符
print('a 1A'.islower()) #判断是不是小写
print('a 1A'.isnumeric()) #是不是只有数字
print('My Name Is '.isprintable()) #能不能打印，字符串里用不着，tty file,drive file不能打印
print('My Name Is '.isupper()) #是不是大写
p = str.maketrans("abcdef",'123456')
print('alex li'.translate(p))
print('Alex Li'.swapcase()) #大小写互换
print('alex li'.zfill(50)) #长度不够的前面补0

字典操作：

字典一种key-value的数据类型
字典的特性：
dict是无序的，可变的
key必须是唯一的，so天生去重

# 格式: 字典名 = {键值1: 实值1, 键值2: 实值2, .....}
# 键值1: 实值1 统称为 键值对  key value 也称之为元素
# 键值数据类型的选择: 必须是不可变的
# 键值 的名字不能重复(才能完成1对1 通过一个key 获取key 的value)
# 字典的key 一般都是使用字符串
# 字典的value 没有规定 (可以重复的)
my_dict = {"name": "小明", "age": 22, "no": "007"}
# 三个元素(键值对)
print(len(my_dict))  # 3
# 定义一个特殊 (空字典)
my_dict1 = {}
print(len(my_dict1))  # 0
print(type(my_dict1))  # <class 'dict'>
my_dict2 = dict()
print(type(my_dict2))  # <class 'dict'>

# <1>修改元素
# 字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改
# 通过key 获取对应key的value的值
my_dict = {"name": "小红", "age": 22, "no": "009"}
print(my_dict["age"])
# 通过key 修改对应key的value的值
my_dict["age"] = 220
print(my_dict)
# <2>添加元素
# 格式: 字典名[key] = value
# 如果在使用 变量名['键'] = 数据 时，这个“键”在字典中，不存在，那么就会添加一组键值对。
# 如果使用上面的格式 如果这个key存在 会把key原来的value的值进行覆盖
my_dict["title"] = "哈哈"
print(my_dict)
# <3>删除元素
# 对字典进行删除操作，有一下几种：
# del (python内置函数)
# clear()
my_dict = {"name": "小红", "age": 22, "no": "009"}
# 删除键值对 格式: del 字典名[key]
del my_dict["no"]
print(my_dict)
# clear 删除字典中的所有的元素
my_dict.clear()
# 等价于 my_dict = {} 或者 my_dict = dict()
print(my_dict)  # {}

info = {
　　'stu1101':"TengLian Wu",
　　'stu1102':"LongZe LuaLa",
　　'stu1103':"XiaoZe MaLiya",
}
print(info)
print(info['stu1101']) #百分百确定有这个key再用这个方式查找
print(info.get('stu1104')) #查找，有就返回，没有None
print('stu1103' in info) #判断在不在
info.pop('stu1102') #删除
info.popitem() #随机删除
print(info)

my_dict = {"name": "小红", "age": 22, "no": "009"}
# <1>len()
# 测量字典中，键值对的个数
l = len(my_dict)
print("元素数:%d" % l)  # 元素数:3
# <2>keys
# 返回一个包含字典所有KEY的列表
keys = my_dict.keys()
print(keys)  # dict_keys(['name', 'age', 'no'])  其实就是列表类型 dict_keys
# 如果想转成list类型也可以
print(list(keys))  # ['name', 'age', 'no']
# <3>values
# 返回一个包含字典所有value的列表
values = my_dict.values()
print(list(values))  # ['小红', 22, '009']
# <4>items -> 最外层是一个列表 每个元素是一个元组 (元素1(key), 元素2(value))
items = my_dict.items()
print(items)  # dict_items([('name', '小红'), ('age', 22), ('no', '009')])
print(list(items))  # [('name', '小红'), ('age', 22), ('no', '009')]

遍历

# 可以遍历的 字符串 列表 元组 字典 -> for循环
# 自定义一个列表 快速创建一个有规律的列表
my_list = list("abcd")
print(my_list)  # ['a', 'b', 'c', 'd']
for value in my_list:
    print(value)
# 自定义一个元组
my_tuple = tuple("123456")
print(my_tuple)  # ('1', '2', '3', '4', '5', '6')
for value in my_tuple:
    print(value)
# 定义一个字典
my_dict = {"name": "小红", "age": 22, "no": "009"}
# 遍历-key
for key in my_dict.keys():
    print(key)
# 遍历value
for value in my_dict.values():
    print(value)
# 遍历items
for item in my_dict.items():  # item这个临时变量的类型是元组
    print(item[0])
    print(item[1])
# 通过设置两个临时变量
for key, value in my_dict.items():
    print("key:", key)
    print("value:", value)
# 如果想使用元素和下标索引 请使用enumerate(列表名)
my_list = list("abcd")
# 不仅要获取列表中的元素 而且需要知道这个元素下标索引
for i, value in enumerate(my_list):
    print(i,value)

info = {
　　'stu1101':"TengLian Wu",
　　'stu1102':"LongZe LuaLa",
　　'stu1103':"XiaoZe MaLiya",
}
for i in info:
　　print(i,info[i]) #高效
for k,v in info.items(): #把字典转成列表的过程
　　print(k,v)

多级字典嵌套：

av_catalog={
"欧美":{
　　"www.youporn.com":["很多免费的，世界最大的","质量一般"],
　　"www.pornhub.com": ["很多免费的，也很大", "质量比youporn高点 "],
　　"letmedothistoyou.com": ["多是自拍，高质量图片很多", "资源不多，更新慢"],
　　"x-art.com": ["质量很高，真的很高", "全部收费，屌比请绕过"],
　　},
"日韩":{
　　"tokyo-hot": ["质量怎样不清楚，个人已经不喜欢日韩范了", "听说是收费的"],
　　},
"大陆": {
　　"1024": ["全部免费，真好，好人一生平安", "服务器在国外，慢"],
　　}
}
av_catalog['大陆']['1024'][1]="可以在国内做镜像"
print(av_catalog)

info = {
　　'stu1101':"TengLian Wu",
　　'stu1102':"LongZe LuaLa",
　　'stu1103':"XiaoZe MaLiya",
}
print(info.values())
print(info.keys())
info.setdefault('stu1104',"haha")
info.setdefault('stu1101',"haha") #有这个key就返回，没有创建
print(info)

info = {
　　'stu1101':"TengLian Wu",
　　'stu1102':"LongZe LuaLa",
　　'stu1103':"XiaoZe MaLiya",
}
b = {
　　'stu1101':"Alex",
　　1:3,
　　2:5
}
info.update(b) #有交叉就更新，没有创建
print(info)
c = dict.fromkeys([6,7,8],"test") #初始化一个新的字典，三个key共享一个value，一个内存地址，即使修改，value也都一样
print(c)
print(info.items()) #把字典转成了列表

三级菜单：

data = {
　　'北京':{
　　　　"昌平":{
　　　　　　"沙河":["oldboy","test"],
　　　　　　"天通苑":["链家地产","我爱我家"]
　　　　},
　　　　"朝阳":{
　　　　　　"望京":["奔驰","陌陌"],
　　　　　　"国贸":["CICC","HP"],
　　　　　　"东直门":["Advent","飞信"]
　　　　},
　　　　"海淀":{}
　　　　},
　　'山东':{
　　　　"德州":{},
　　　　"青岛":{},
　　　　"济南":{},
　　　　},
　　'广东':{
　　　　"东莞":{},
　　　　"常熟":{},
　　　　"佛山":{}
　　　　}
}
while True:
　　for i in data:
　　　　print(i)
　　choice = input("一级菜单请选择进入>>:")
　　if choice in data:
　　　　while True:
　　　　　　for i2 in data[choice]:
　　　　　　　　print("	",i2)
　　　　　　choice2 = input("二级菜单请选择进入>>:")
　　　　　　if choice2 in data[choice]:
　　　　　　　　while True:
　　　　　　　　　　for i3 in data[choice][choice2]:
　　　　　　　　　　　　print("		", i3)
　　　　　　　　　　choice3 = input("三级菜单请选择进入>>:")
　　　　　　　　　　if choice3 in data[choice][choice2]:
# 　　　　　　　　　　 while True:
　　　　　　　　　　　　for i4 in data[choice][choice2][choice3]:
　　　　　　　　　　　　　　print("			",i4)
　　　　　　　　　　　　choice4 = input("最后一层，按b返回>>:")
　　　　　　　　　　　　if choice4 == "b":
# 　　　　　　　　　　　　 break
　　　　　　　　　　　　　 pass
　　　　　　　　　　if choice3 == "b":
　　　　　　　　　　　　break
　　　　　　if choice2 == "b":
　　　　　　　　break

data数据如上

exit_flag = False
while not exit_flag:
　　for i in data:
　　　　print(i)

　　choice = input("请选择进入1>>:")
　　if choice in data:
　　　　while not exit_flag:
　　　　　　for i2 in data[choice]:
　　　　　　　　print("	",i2)
　　　　　　choice2 = input("请选择进入2>>:")
　　　　　　if choice2 in data[choice]:
　　　　　　　　while not exit_flag:
　　　　　　　　　　for i3 in data[choice][choice2]:
　　　　　　　　　　　　print("		", i3)
　　　　　　　　　　choice3 = input("请选择进入3>>:")
　　　　　　　　　　if choice3 in data[choice][choice2]:
　　　　　　　　　　　　for i4 in data[choice][choice2][choice3]:
　　　　　　　　　　　　　　print("			",i4)
　　　　　　　　　　　　choice4 = input("最后一层，按b返回>>:")
　　　　　　　　　　　　if choice4 == "b":
　　　　　　　　　　　　　　pass
　　　　　　　　　　　　elif choice4 == "q":
　　　　　　　　　　　　　　exit_flag = True
　　　　　　　　　　if choice3 == "b":
　　　　　　　　　　　　break
　　　　　　　　　　elif choice3 == "q":　　　　　　　　
　　　　　　　　　　　　exit_flag = True
　　　　　　if choice2 == "b":
　　　　　　　　break
　　　　　　elif choice2 == "q":
　　　　　　　　exit_flag = True

获取value的值：name[key]和name.get[key]的区别

前者key必须存在，否则报错，后者key不存在，返回None