python数据类型

注释

对代码的解释说明，注释的内容不会被当作代码运行
目的是为了增强代码的可读性

# 单行注释
'''
代码注释：
	在自己觉得必要的地方添加注释
	推荐使用英文和中文，不推荐使用拼音
'''

变量

变量就是可以变化的量，程序执行的本质就是一系列状态的变化，变是程序执行的直接体现，所以我们需要有一种机制能够反映或者说是保存下来程序执行时状态，以及状态的变化，这就需要变量
命名规范：

• 变量名只能是字母、数字或下划线的任意组合
• 变量名的第一个字符不能是数字
• 关键字不能声明为变量名
  命名风格：
• 驼峰体：AgeOfTony = 56
• 纯小写下划线(在python中推荐使用该风格)：age_of_tony = 56
  变量的三个要素：
• id：反应的是变量在内存中的唯一编号，内存地址不同id肯定不同，可通过函数id(变量名)进行查询
• 变量的类型，可通过type（变量名）进行查询
• 变量值value

常量

一些数据在程序中不应该被改变（比如圆周率），这时就需要常量
在Python中没有一个专门的语法定义常量，约定俗成是用全部大写的变量名表示常量。如：PI=3.14159。所以单从语法层面去讲，常量的使用与变量完全一致。

基本数据类型

1. 整型（int）：就是数学中的整数
2. 浮点型（float）：就是我们生活中的小数
3. 字符串类型（str）：就是字符串
4. 布尔值（boolean）：进行逻辑判断的对与错，对是true，错是false
5. 列表（list）：容器类型，能装多个数据，是可变的数据类型
6. 字典（dict）：容器类型，由键值对组成，键对值有描述的作用，这样有利于数据的获取
7. 集合（set）：容器类型，集合里面的元素必须是不可变的数据类型并且不能重复，主要用于关系运算与数据的去重
8. 元组（tuple）：容器类型，相对于列表来说，元组数不可变的数据类型

# 整型
age=10
# 浮点型
salary=6666.6
# 字符串类型
a='今天是个好日子'
b="明天还是好日子"
c="""
     三个双引号可以引用多行文本
	 你说厉不厉害
     """
d='''
	 三个单引号可以引用多行文本
	 你说厉不厉害
	 '''
# 布尔值
e=True
f=False
# 列表
g=[1,'a',True,[1,2,3]]
# 字典
h={'name':'libai','age':18,'marry':False,'hobbies':['sing','jump','rap']}
# 集合
i={1,2,3}
# 元组
j=(1,2,3)
k=(4,)  # 必须加上逗号

基本数据类型的内置方法

介绍一些常用的内置方法

字符串

# 1. 类型转换：str()函数
s1=str([1,2,3])  # 转换成'[1,2,3]'
# 2. 索引取值：也叫字符串的切片
s2='hello world'
s3=s2[2]  # 'l'
s4=s2[0:6:2]  # 返回'hlo' 三个数分别是开始位置，结束位置，隔几个位置去一个值
s4=s2[-1]  # 'd' 可以倒着取值
s5=s2[::-1] # 反向切片 返回'dlrow olleh'
# 3. 成员运算：
'i' in s1  # 返回False
'i' not in s1  # 返回True
# 4. 内置方法
len(s1)  # 返回字符串的长度
# 5. 移除字符串首尾的字符串
s1.strip()  # 移除首尾的空格
s1.lstrip()  # 移除左边的空格
s1.rstrip()  # 移除右边的空格
s1.strip('h')  # 移除指定的符号
# 5. 切分字符串
l1=s1.split(' '，1)  # 返回列表，里面是分割后的字符串，括号里面可以指定分割的字符，第二个参数是分割的次数，第二个参数不写默认是分割全部
l1=s1.rsplit(' '，1)  # 用法一样，只不过是从右边开始切割
# 6. 将分割的列表按照指定的字符连接起来
','.join(l1)
# 7. 大写和小写
s1.upper()  # 将字符串全大写
s1.lower()  # 将字符串全小写
# 8. 判断字符串的开头和结尾
s1.startswith('hell')  # 判断字符串是否是'hell'开头的，返回True
s1.endswith('ip')  # 判断是否为'ip'结尾，返回False
# 9. 替换replace
s1.replace('旧内容', '新内容', 1)  # 用旧内容替换新内容，数字指代替换的次数，不写默认替换全部
# 10. 一些判断
s1.isdigit()  # 判断字符串是否是纯数字组成，返回结果为True或False
name = 'tony123'
name.isalnum() # 字符串中既可以包含数字也可以包含字母
name.isalpha() # 字符串中只包含字母
name.islower()  # 字符串是否是纯小写
name.isupper()  # 字符串是否是纯大写
name.isspace()  # 字符串是否全是空格
name.istitle()  # 字符串中的单词首字母是否都是大写

num5 = '4.3'
num5.isdigit()  # isdigt:bytes,unicode
num5.isdecimal()  # uncicode(bytes类型无isdecimal方法)
num5.isnumeric()  # unicode,中文数字,罗马数字(bytes类型无isnumberic方法)
# 简单来说，最常用的是isdigit，当判断中文大写数字和罗马数字时使用isnumeric
# 11. count判断出现的次数
s1.count('a')  # s1里面的'a'出现的次数
s1.count('a',0,6)  # s1的0到6的字符串里面'a'出现的次数
# 12. 查找索引
s1.find('o',1,3)  # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引，找不到返回-1
.rfind()  # 用法同上，只是从右边开始查找
s1.index('e',2,4) # 在索引为1和2(顾头不顾尾)的字符中查找字符o的索引，找不到报错
.rindex()  # 用法同上，只是从右边开始查找
# 13. 调整和填充
name='tony'
name.center(30,'-')  # 总宽度为30，字符串居中显示，不够用-填充
-------------tony-------------
name.ljust(30,'*')  # 总宽度为30，字符串左对齐显示，不够用*填充
tony**************************
name.rjust(30,'*')  # 总宽度为30，字符串右对齐显示，不够用*填充
**************************tony
name.zfill(50)  # 总宽度为50，字符串右对齐显示，不够用0填充（z是zero）
0000000000000000000000000000000000000000000000tony

name = 'tony\thello'  # \t表示制表符(tab键)表示三个空格
name.expandtabs(1)  # 修改\t制表符代表的空格数，变成一个空格
tony hello
# 4.1 captalize：首字母大写
>>> message = 'hello everyone nice to meet you!'
>>> message.capitalize()
Hello everyone nice to meet you!  

# 大小写转换
msg1 = 'Hi girl, I want make friends with you!'
msg1.swapcase()  # 将大小写转换，大写变小写小写变大写
hI GIRL, i WANT MAKE FRIENDS WITH YOU!  
msg2 = 'dear my friend i miss you very much'
msg2.title()
Dear My Friend I Miss You Very Much 

数字

# 1. 类型转换
int(str1)  # 转换成整型，只能是全部由数字组成的字符串才能转换，否则会报错
float(str1)  # 转换成浮点型
# 2. 进制转换
bin(11)  # 转换成二进制
oct(11)  # 转换成八进制
hex(17)  # 转换成十六进制的数字
int('0b11',2)  # 二进制转换回十进制
int('0o11',8)  # 八进制转换成十进制
int('0x11',16)  # 十六进制转换成十进制

列表

列表是容器类元素，主要是对其进行增删改查

l1=[1,2,3,4,5,6,7,8]
# 1. 基础操作
list('nihao')  # 类型转换['n','i','h','a','o']
li[0:6:2]  # 索引取值,分别是起始位置，结束位置，步长，返回[1,3,5]
len(l1)  # 计算长度，返回8
9 in l1  # ，成员判断，返回False
for i in l1：
	print(i)  # 遍历取值，打印每一个元素
#  2. 增
l1.append(9)  # 在最后追加
l1.extend([10,11])  # 迭代着追加
l1.insert(0,0)  # 第一个参数是添加的索引位置，第二个参数是添加的元素
# 3. 删
res=l1.pop()  # 括号里面不加参数默认删除最后一个元素，也可以添加删除的元素的索引值，返回值是删除的元素
del l1[10]  # 删除指定的元素
res=l1.remove(9)  # 括号里面是元素的值，pop是按照索引删除，remove是直接删除元素的值
# 4. 查：直接使用索引进行查看
# 5. 改
l1[0]='0'  # 对其进行赋值可以直接改变列表
# 6. 其他的一些操作
l1.reverse()  # 将列表倒转，元素的顺序倒转
l1.sort()  # 将元素进行排序，默认是从小到大，元素的类型一致才能进行比较，字符比较的是ASCII码
l1.count()  # 查找元素出现的次数
l1.index()  # 查找元素的索引
l1.clear()  # 清空元素，将列表变为空列表

元组

# 类型转换
tuple('nihao')  # ('n','i','h','a','o')
# 元组是不可变的数据类型，不能修改里面的元素
# 元组可以索引取值、成员运算、长度计算，以及使用for循环取值
# 注意：用元组表示一个元素的时候，需要在后面添加逗号，如(1,)

字典

# 字典是由键值对组成的，键（key）必须是不可变的数据类型并且不能重复，值（value）可以是任意的数据类型
# 空字典{}
# 字典的创建
d=dict(x=1,y=2,c=3)
l=[[1,'a'],[2,'b'],[3,'c']]
d1=dict(l)  # 直接得到字典{1:'a',2:'b',3:'c'}
key1=[1,2,3]
none
{}.fromkeys(key1,none)  # 得到字典{1：none,2:none,3:none}，原理将前面的可迭代对象的每一个元素都当做key，值是同一个，都是none，这种方式常常用于快速初始化一个字典，值的部分通常不使用可变的数据类型，一般是none，或者是可变的数据类型

# 改/增
d1={1:'a',2:'b',3:'c'}
d1[1]  # 查看值，如果键值对不存在会直接报错
d1.get(1，'当key不存在的时候get方法的返回值')  # 是为了弥补使用索引进行查询的时候，如果字典中没有对应的键会直接报错，但是get方法会返回none
d1[1]='asd'  # 键存在的话就是直接修改值
d1[4]='d'  # 如果key不存在的话就直接增加键值对

# 长度计算
len(d1)

# 成员运算in 和 not in判断的是key

# 删
del d1[1]  # 直接删除键值对
d1.pop(1)  # 默认删除最后一个，或者按照键删除，返回删除的key对应的值
d1.popitem()  # 随机删除，返回删除键值对组成的元组

# 其他的一些方法，下面是在python2中得到的结果，在python3中进行了优化，将每个得到的结果换成了迭代器，为了节省内存空间
d1.keys()  # 得到key组成的列表
d1.values()  # 得到value组成的列表
d1.items()  # 得到键值对组成的元组形成的列表

d1.clear()  # 全删除，清空
d1.update(d2)  # 在d1中有的键值对，还继续保留，d1中没有d2中有的键值对，将其增加到d1中
d1.setdefault(1，'abc')  # 如果键值在原字典中存在，就不会对原字典进行修改
d1.setdefault(5,'e')  # 如果键不存在，就将键和默认值形成键值对添加到字典中

集合

集合有两个用处，一个是关系运算，一个是去重
在{}内用逗号分隔开多个元素，元素满足以下条件：
​ 集合内元素必须是不可变类型
​ 集合内元素无序
​ 集合内元素没有重复
{}是空集合，不是空字典，集合的函数是set（）

# 类型转换
s=set('abcde')  # {'a','b','c','d','e'}要注意的是，集合里面放的是不可变的数据类型
# 集合的关系运算与相关的内置方法
s1={1,2,3,4,5}
s2={2,3,4,5,6}
# 取交集，两个集合共有的元素
s1&s2  # {2,3,4,5}
s1.intersection(s2)
# 取并集，两个集合相加去重
s1|s2  # {1，2,3,4,5，6}
s1.union(s2)
# 取s1独有的元素（差集）
s1-s2  # {1}
s1.difference(s2)
# 对称差集，就是两个元组所独有的元素组成的集合
s1^s2  # {1，6}
s1.symmetric_difference(s2)
# 父子集，包含的关系若s1的元素包含s2里面的元素，就称s1是父集合，s2是子集合（两个集合相等就互为父子）
s1>s2  # 用大于小于表示，返回true或者false，这里的s1和s2不存在父子关系，返回false
s1.issuperset(s2)
s1.subset(s2)

# 集合的去重（有局限性）
# 局限1.只能针对不可变的数据类型进行去重
# 局限2.无法保证原来的顺序

# 集合可以计算长度len()方法
# 集合可以进行成员运算in和not in
# 集合可以用for方法进行循环
# s1.remove(1)  # 可以删除元素，但是删除不存在的元素会报错所以有了discard方法
# s1.discard(9) # 同样可以删除，但是删除不存在的元素的时候什么都不会做，相当于没进行操作
# s1.update(s3)  # 将新集合加到原来的集合中在将重复的去掉（相当于取并集）
# update方法可以和交集并集等方法运算的函数结合使用，下面举个例子就明白了
s1.deiierence_update(s2)  # 就是先去差集然后在进行update
s1.clear()  # 将集合进行清空
s1.pop()  # 随机删除
s1.add(8)  # 增加元素
s1.isdisjoint()  # 如果两个集合完全独立，没有共同部分，返回true

可变与不可变数据类型

可变数据类型：值发生改变时，内存地址不变，即id不变，证明在改变原值（字典和列表）
不可变类型：值发生改变时，内存地址也发生改变，即id也变，证明是没有在改变原值，是产生了新的值（字符串、数字、元组、集合）

补充知识

1. 整型和浮点型的加减乘除不在赘述，和数学里面的一样
2. 字符串能够相加，并且能和数字相乘
3. 格式化字符串

l='你'+'好'
# l---->你好
m='你'*3
# m='你你你'

# 格式化输出之format
str1 = 'my name is {}, my age is {}!'.format('tony', 18)
# 返回my name is tony, my age is 18!
str2 = 'my name is {0}, my age is {1}!'.format('tony', 18)
str3 = 'my name is {name}, my age is {age}!'.format(name='tony', age=18)

# 格式化输出：占位符
str4 = 'my name is %s, my age is %d!'%('tony', 18)

# 格式化输出：f字符串方法
f'my name is {name},my age is {age}' # 这种方法python3.5以后才有