基本数据类型

# Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
# 在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
# 等号（=）用来给变量赋值。
# 等号（=）运算符左边是一个变量名,等号（=）运算符右边是存储在变量中的值。
# 变量定义的规则：
# 1.变量名只能是 字母、数字或下划线的任意组合
# 2.变量名的第一个字符不能是数字
# 3.以下关键字不能声明为变量名
# ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else',
#  'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
#  'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']
# python中的数据又称为对象，每创建一个对象都会创建三个属性
# 一：身份id
# 二：类型type
# 三：值
# is：比较id,id一样，类型肯定一样，值肯定也一样
# ==：比较的是值

# 基本的数据类型：
# num数字
# str字符串
# 它是一个有序的字符的集合，用于存储和表示基本的文本信息，‘’或“”或‘’‘ ’‘’中间包含的内容称之为字符串

#  list列表 可迭代对象
# []内以逗号分隔，按照索引，存放各种数据类型，每个位置代表一个元素

# tuple元组
# 与列表类似，只不过［］改成（）

# dict字典
# 字典是一种映射类型，字典用"{ }"标识，它是一个无序的键(key) : 值(value)对集合。
# 键(key)必须使用不可变类型。在同一个字典中，键(key)必须是唯一的。

# set集合 无序不重复元素的序列

# 一：可变不可变
# 可变数据类型：列表 字典 集合
# 不可变数据类型：数字 元组 字符串
# 二：存放值的个数
# 一个值：数字，字符串
# 多个值(容器类型)：列表，元组，字典
# 三：取值方式
# 直接取值：数字
# 序列类型：字符串，元组，列表
# 映射：字典


# num数字
# int整型
# float浮点型   Python的浮点数就是数学中的小数
# bool布尔值   True和False   1和0
# complex复数   复数由实数部分和虚数部分组成，一般形式为x＋yj，其中的x是复数的实数部分，y是复数的虚数部分，这里的x和y都是实数。

# 布尔值
# None '' () [] {} 0  都是False
#1 -1 都是True

#数字
# m=10
# a=m.bit_length() #当前数字的二进制，至少用n位表示
# print(a)

# 将字符串转换成数字
# num='b'
# v=int(num,base=16)#把b以十六进制方式转换成10进制
# print(v)
# print(bin(10))#十进制转换成二进制
# print(oct(10))#十进制转换成八进制
# print(hex(16))#十进制转换成十六进制

# 列表list
l=[1,2,3,3,4,5,6,7,'z']
l1=['jack']
# 查
# print(l.index(3))#返回3这个元素的索引
# a=l.count(3)#统计3的个数
# print(a)
# print(len(l))#统计l中有几个元素

# 切片
# print(l[2:5])#第三个到第四个
# print(l[-2:])

# 增
# l.append('a') #追加
# print(l)
# l.insert(3,'abc')#把abc插到索引3的位置
# print(l)
# l.extend([7,8])#在最后插入多个
# l.extend('asd')#在最后插入'a','s','d'
# print(l)
# l.extend(l1)
# print(l)
# l=l+l1
# print(l)



# 删
# l.pop(5)  #删除索引为5的元素,默认删除最后一个值
# print(l)
# l.remove('z')#删除z这个元素
# print(l)
# del l[2]#删除索引为2的元素
# print(l)
# del l #删除列表

# 改
# l[2]=555 #赋值操作
# print(l)
# l.clear() #没动内存空间，只清理了值
# print(l)
# l=[]   #推荐这种方式   指向空列表的内存地址

# l1=[2,3,5,6,4,1]
# l1.sort(reverse=True)   #排序，reverse=Ture表示从大到小排，不写默认从小到大
# print(l1)
# l1.reverse()#反转
# print(l1)
# print(l1.copy())#浅拷贝

#队列：先进先出
# l=[]
# #入队列
# l.append('people1')
# l.append('people2')
# l.append('people3')
# print(l)
# #出队列
# print(l.pop(0))
# print(l.pop(0))
# print(l.pop(0))
#
# #insert
# l.insert(0,'people1')
# l.insert(0,'people2')
# l.insert(0,'people3')
# print(l.pop())
# print(l.pop())
# print(l.pop())
# #堆栈：先进后出或后进先出
# l=[]
# #入队列
# l.append('people1')
# l.append('people2')
# l.append('people3')
# print(l)
# #出队列
# print(l.pop())
# print(l.pop())
# print(l.pop())

# 元组 一级元素不能被修改，删除和增加
# tu=(11,22,22,33,44)
# print(tu.count(22))#统计22的个数
# print(tu.index(22))#第一个22的索引


# 字典dict
# d1={}
# d2=dict(x=1,y=2)
# d3=dict({'x':1,'y':2})
# 字典的value可以是任何值
# 字典可以有多个key，只有后面的才会生效
#字典的key必须是不可变类型，或者说是可hash类型
# print(hash(1))
# print(hash('xxx'))
# print(hash((1,2,3)))
# print(hash([1,2,3]))
# print(hash({'a':1,'b':2}))
# 列表、字典不能作为字典的key,布尔值能作为key,但会和1,0重复，导致无法显示
# python中唯一具有映射关系的数据类型： 字典的查询效率高于列表
# 创建
# d={[1,2,3]:"yuan","name":"egon"}# 键唯一且为不可变数据类型
# d={1:"yuan","name":"egon"}

# 查
# v=d['name']#找不到key会报错
# print(v)
# v=d.get("names",None)  #推荐,key不存在，返回默认值（None）
# print(v)

# d={5:"yuan","name":"egon"}
# for i in d:
#     print(i)#遍历keys
#     print(i,"----->",d[i])
#     print("%s---->%s======"%(i,d[i]))
# for i in d.values():
#     print(i)#遍历value
# for k,v in d.items():
#     print(k,v)#取keys和values
# for i,v in enumerate(list,1):#遍历列表或字符串的索引和值，1表示索引起始值，可不写，默认为0
#     print(i,v)



# 增
d={5:"yuan","name":"egon"}
# d["age"]=123
# print(d)

# 修改
# d[1]=666
# print(d)

# 删除
# ret=d.pop(5,'None')#删除d中key值为5的元素，后面加默认值找不到不会报错
# print(ret)
# print(d)
# del d[5]#删除d中key值为5的元素
# print(d)
# v=d.popitem() #随机删一个键值对
# print(v)
# d2={"height":123,"sex":"male","name":"alex"}
# d.update(d2)#更新 把d2增加到d，key一样就覆盖
# print(d)
# print(list(d.keys()))#查找d所有的key,以列表的形式打印
# print(d.values())#查找d所有的value
# print(d.items())
#已存在，不设置，获取当前key对应的值
#不存在，设置新的key和value值
# v=d.setdefault('k111','123')
# print(d,v)
#两种更新方式，已经有的直接覆盖,没有的更新
# d.update({'k1':'1111','k3':123})
# print(d)
# d.update(k1=1111,k3=123)
# print(d)
# d6={}.fromkeys(['name','age'],None)#{'name': None, 'age': None}
# print(d6)



# 集合set
# s=frozenset('hello')#不可变集合
# 两个功能：1 去重 2关系测试
# s1=set([1,3,"hello"])
# s2={1,2,3}
# print(s1)
# print(type(s2))
# print(s.add())#增加一个值
# s.update(s2)#更新多个值
# print(s1)
# print(s1.clear())#清空
# print(s1.copy())#拷贝
# print(s1.remove())#删除指定元素，不存在会报错
# print(s1.pop())#随机删
# print(s1.discard())#删除指定元素，不存在不会报错


#去重：
# l=[1,2,2,34,45]
# s="hello"
# print(set(l))
# print(set(s))

# print({{1,2}:"hello"})#  set是可变数据类型
# print({[]:"hello"})

# s3={1,2,[1,2]}     #  set集合内元素一定是不可变数据类型
# print(s3)

#关系测试
# s1={"hello",1,2,3}
# s2={1,2,("a","b")}

# 取二者所有的元素：求并集
# print(s1.union(s2)) # {1, 2, 3, ('a', 'b'), 'hello'}
# print(s1|s2)

# 取共同部分：求交集
# print(s1.intersection(s2))# {1, 2}
# print(s1&s2)
# print(s1.isdisjoint(s2))#没有交集返回True

# 求差集
# print(s1.difference(s2))# {3, 'hello'}
# print(s1-s2)
# print(s2.difference(s1))# {('a', 'b')}
# print(s2-s1)

#对称差集
# print(s1.symmetric_difference(s2))# {3, 'hello', ('a', 'b')}
# print(s2.symmetric_difference(s1))# {3, 'hello', ('a', 'b')}
# print(s1^s2)#去掉相同的元素然后并集




# 字符串
# 切片
# s='hellowoRld'
# print(s[1:4])    #取第二个到第四个元素
# print(s[1:8:2])   #2 是步长  第二个到第七个每隔两个取个元素
# print(s[-1])      #取最后一个元素
# print(s[:])    #从头取到尾
# print(s[:8])    #取到第八个
# print(s[1:-1])   #第二个取到倒数第二个
# print(s[1:])   #第二个取到最后
# print(s[-3:-1])    #取倒数第三个到最后第二个

#查找
# print(s.find('l',5))   #从第5个开始找第一个l的索引  找不到返回-1
# print(s.rfind('l'))   #从右边开始找第一个l的索引
# print(s.index('e'))#找到元素e的下标  找不到会报错

# print(s.replace('hello','python',1))  #找到hello，替换成python,替换一次
# print(s.upper())#全部变大写
# print(s.strip()) #删除字符串前面和后面的空格和换行符
# print(s.lstrip()) #删除字符串左边的空格和换行符
# print(s.rstrip()) #删除字符串右边的空格和换行符
# s1="**hello
world
***"
# print(s1)
# print(s1.strip("*"))  #删除字符串前面和后面的*和换行符
# print(s.startswith('h'))#以什么开头，返回布尔值
# print(s.endswith('l')) #以什么结尾，返回布尔值

# print(s.isidentifier())
# print(s.center(20,'*'))#s居中，*在两边，20代指总长度
# print(s.ljust(50,"*")) #左对齐
# print(s.rjust(50,"*")) #右对齐
# print(s.zfill(20)) #右对齐,左边用0填充
# print(s.capitalize())  #第一个单词首字母变大写
# print(s.title())  #每个单词的首字母变大写
# print(s.casefold())  #每个字母都变成小写，能处理特殊字符
# print(s.lower())# 每个字母都变成小写，只能处理普通字符(英文字母)
# print(s.swapcase())#把大写变小写，把小写变大写
# print(s.title())#把首字母变大写

#分割
# print("hello world".split("l",1))    # ["he","lo world"]  l用来分割左右,1是分割次数
# a=s.split("l",3)
# print(type(a)) #类型为列表
# print("HLLO world".rsplit())   #从右边开始分割
# print("HELLO
 wor
ld
".splitlines())    #以
来分割字符，最后没有空
# print("HELLO
 wor
ld
".split("
"))    #会分最后一个空
# print("HELLo world".zfill(20))      #一共20个字符，前面补0，内容右对齐，字符个数小于本身结果不变

#遍历
# for i in "hello":
#     print(i)


# 字符串拼接
# s="hello"+"world"+"I"+"am"+"python"
# print(s)
# l=['h','e','l','l','o']
# print(''.join(l))
# 字符串的格式化输出
# %s:字符串   %d:整型  %f:浮点型
# print('hello %s,%s'%('hehe','haha'))
# print('his age is %d'%25)
# print('hello %s,his age is %d'%('egon',25))
# print('hello %s,his age is %.4f'%('egon',25.1234456))
# print("hello {}, his age is {},sex is {}".format('alex',20,'male'))
# print("hello {0}, his age is {1},sex is {0}".format('alex',20))
# print("hello {name}, his age is {age}".format(age=30,name="egon")) #键值对，推荐
# print("hello {name}, his age is {age}".format(**{'age':30,'name':"egon"}))
# print("hello {name}, his age is {age}".format_map({"name":"egon","age":1000})) #字典数据
#判断是否是数字
# print("一".isdecimal())
# print("一".isdigit())       #不支持负数，常用
# print("壹".isnumeric())   #支持最多的

#补充
# str='HEllo'
# sub='l'

# print('hello	world'.expandtabs(20))#hello	一共占20个
# print(s.count(sub,0,4))#sub在str中在索引[0,4]中存在两次
# print(s.isalnum())#所有字符都是字母或数字则返回 True,否则返回 False
# print(s.isalpha())#所有字符都是字母则返回 True,否则返回 False
# print(s.islower())#所有这些字符都是小写则返回 True，否则返回 False
# print(s.isupper())#所有这些字符都是大写，则返回 True，否则返回 False
# print(s.isspace())#只包含空格，则返回 True，否则返回 False
# print(s.istitle())#判断首字母是否是大写，是返回True