'''
1.整型
即int类型，无论整型数字多大多小都属于int。
代码：
x = 10
print(type(x)) #
1.1整型数字之间进制关系
# 十六进制
print(0x11)
print(0x111)
# 二进制
print(0b101)
print(0B101)
# 八进制
print(0o12)
print(0o23)
# 十进制转换为二进制
print(bin(3))
# 十进制转换为十六进制
print(hex(19))
# 十进制转换为八进制
print(oct(10))
==============================
2.浮点型
在python中小数都属于浮点型(float）,有两种表现形式
2.1小数点形式
f = 3.14
print(f) # 3.14
print(type(f)) #
f3 = 3.1415926123456789876543217789
print(f3) # 双精度(double float,保留17为有效数字)
print(type(f3))
2.2指数形式： aEn 或 aen
3.2E5 = 3.2×105，其中 3.2 是尾数，5 是指数。
2.7E-3 = 2.7×10-2，其中 2.7 是尾数，-3 是指数。
0.2E8 = 0.2×107，其中 0.2 是尾数，8 是指数。
f1 = 3.2E5
print(f1) # 320000.0
print(type(f1)) #
f2 = 3.2E-5
print(f2) # 3.2e-05
print(type(f2)) #
==============================
3.布尔类型
布尔型（Boolean）是一种数据的类型，这种类型只有两种值，即"真"与"假"。在python中用 bool表示布尔类型，“真"用关键字true表示，“假"用false表示。
print(4 == 2) # False
name = "xi"
print(name == "alvin") # False
print(1 == "1") # False
3.1零值
不光表达式的结果是布尔值，任意值都有自己的布尔值，这就涉及到布尔的零值。
# 任意数据类型都一个具体值的布尔值为False,我们称为零值。该类型的其他值的布尔值皆为True。
print(bool("")) # 字符串的零值 “”
print(bool(0//代码效果参考：http://www.zidongmutanji.com/bxxx/156834.html
)) # 整型的零值 0print(bool(False)) # 布尔类型的零值 False
==============================
4.字符串
字符串是由零个或多个字符组成的有限序列。字符串的内容可以包含字母、标点、特殊符号、中文、日文等全世界的所有字符。
在python中字符串是通过单引号''或者双引号""标识的，Python 字符串中的双引号和单引号没有任何区别！。
s1 = "hi xi"
print(s1)
s2 = ""
print(s2)
s3 = 'xi是最帅!'
print(s3)
4.1字符串的转义符
转义字符 说明
\n 换行符，将光标位置移到下一行开头。
\r 回车符，将光标位置移到本行开头。
\t 水平制表符，也即 Tab 键，一般相当于四个空格。
\a 蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。
\b 退格（Backspace），将光标位置移到前一列。
\ 反斜线
' 单引号
" 双引号
\ 在字符串行尾的续行符，即一行未完，转到下一行继续写。
4.2长字符串
s = """
s = "hi xi\nhi，alvin"
I'm xi
这是一个python解释器路径："D:\nythonProject\nenv\Scripts\python.exe"
长字符串中放置单引号或者双引号不会导致解析错误
"""
print(s)
4.3格式化输出
之前讲到过 print() 函数的用法，这只是最简单最初级的形式，print() 还有很多高级的玩法，比如格式化输出。
name = "xi"
age = 23
print("My name is %s; My age is %d"%(name,age))
在 print() 函数中，由引号包围的是格式化字符串，它相当于一个字符串模板，可以放置一些转换说明符（占位符）。本例的格式化字符串中包含一个%s和%d说//代码效果参考：http://www.zidongmutanji.com/zsjx/453733.html
明符，它最终会被后面的name和age 变量的值所替代。中间的%是一个分隔符，它前面是格式化字符串，后面是要输出的表达式。print() 函数使用以%开头的转换说明符对各种类型的数据进行格式化输出，具体请看下表。
转换说明符 解释
%d、%i 转换为带符号的十进制整数
%o 转换为带符号的八进制整数
%x、%X 转换为带符号的十六进制整数
%e 转化为科学计数法表示的浮点数（e 小写）
%E 转化为科学计数法表示的浮点数（E 大写）
%f、%F 转化为十进制浮点数
%g 智能选择使用 %f 或 %e 格式
%G 智能选择使用 %F 或 %E 格式
%c 格式化字符及其 ASCII 码
%r 使用 repr() 函数将表达式转换为字符串
%s 使用 str() 函数将表达式转换为字符串
4.4归属序列类型
字符串属于序列类型，所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。
s= "hello yuan"
image-20210413141108883
Python 还支持索引值是负数，此类索引是从右向左计数，换句话说，从最后一个元素开始计数，从索引值 -1 开始，如图 所示。
序列类型支持的操作：
# （1）索引取值
s = "hello yuan"
print(s【6】)
print(s【-10】)
# （2）切片取值：序列类型对象【start : end : step】
s = "hello yuan"
print(s【1:4】) # ell ：取索引1到索引3（左闭又开）
print(s【:4】) # hell ：start缺省，默认从0取
print(s【1:】) # ello yuan ： end缺省，默认取到最后
print(s【1:-1】) # ello yua
print(s【6:9】) # yua
print(s【-4:-1】) # yua
print(s【-1:-4】) # //代码效果参考：http://www.zidongmutanji.com/bxxx/58396.html
空print(s【-1:-4:-1】) #nau step为1：从左向右一个一个取。为-1 ，从右向左一个取
# （3）判断存在：Python 中，可以使用 in 关键字检查某元素是否为序列的成员。
s = "hello yuan"
print("yuan" in s) # True
# （4）支持两种类型相同的序列使用“+”运算符做相加操作，它会将两个序列进行连接，但不会去除重复的元素。
# 使用数字 n 乘以一个序列会生成新的序列，其内容为原来序列被重复 n 次的结果
s = "hello"+" yuan"
print(s) # hello yuan
s= ""10
print(s) # **
（5）内置方法（重点）
方法 作用 示例 输出
upper 全部大写 "hello".upper() "HELLO"
lower 全部小写 "Hello".lower() "hello"
startswith() 是否以a开头 "Yuan".startswith("Yu") True
endswith() 是否以a结尾 "Yuan".endswith("a") False
isdigit() 是否全数字 '123'.isdigit() True
isalpha() 是否全字母 'yuan123'.isalpha() False
isalnum() 是否全为字母或数字 'yuan123'.isalnum() True
strip() 去两边空格 " hi yuan \n".strip() "hi yuan"
join() 将多个字符串连接在一起 "-".join(【"yuan","alvin","eric"】) "yuan-alvin-eric"
split() 按某字符分割字符串，默认按空格分隔 "yuan-alvin-eric".split("-") 【'yuan', 'alvin', 'eric'】
find() 搜索指定字符串，没有返回-1 "hello world".index("w") 6
index() 同上，但是找不到会报错 "hello world".index("w") 6
count() 统计指定的字符串出现的次数 "hello world".count("l") 3
replace() 替换old为new 'hello world'.replace(‘world',‘python') "hello python"
format() 格式化方法
# 任意数据对象.方法()实现对数据的某种操作
# 不同数据类型对象支持不同方法
# 字符串类型对象支持哪些方法
s1 = "yuan"
s2 = "RAIN"
# (1) upper方法和lower方法
s3 = s1.upper()
s4 = s2.lower()
print(s3) # "YUAN"
print(s4) # "rain"
s5 = "hello yuan"
s6 = "hi world"
# (2) startswith和endswith：判断字符串是否以什么开头和结尾
print(s5.startswith("hello")) # True
print(s6.startswith("hello")) # False
print(s6.startswith("hi wor")) # True
print(s6.endswith("hi wor")) # False
# (3) isdigit(): 判断字符串是否是一个数字字符串
s7 = "123"
s8 = "123A"
print(s7.isdigit()) # True
print(s8.isdigit()) # False
s9 = "123SAA%#"
print(s9.isalnum()) # False 不能包含特殊符号
# (4) strip(): 去除两端空格和换行符号
s10 = " I am yuan "
print(s10)
print(s10.strip())
name = input("请输入姓名]").strip()
print(name)
# (5) split分割方法: 将一个字符串分割成一个列表
s11 = "rain-yuan-alvin-eric"
print(s11.split("-")) # 【'rain', 'yuan', 'alvin', 'eric'】
# (6) join方法: 将一个列表中的字符串拼接成一个字符串
names_list = 【'rain', 'yuan', 'alvin', 'eric'】
s12 = "-".join(names_list) # 用什么分隔符拼接names_list列表
print(s12,type(s12)) # "rain-yuan-alvin-eric"
==============================
5.列表
列表声明
在实际开发中，经常需要将一组（不只一个）数据存储起来，以便后边的代码使用。列表就是这样的一个数据结构。
列表会将所有元素都放在一对中括号【 】里面，相邻元素之间用逗号,分隔，如下所示：
【element1, element2, element3, ..., elementn】
不同于C，java等语言的数组，python的列表可以存放不同的，任意的数据类型对象。
l = 【123,"xi",True】
print(l,type(l))
# 注意
a,b = 【1,2】
print(a,b)
5.1索引求值
l = 【10,11,12,13,14】
print(l【2】) # 12
print(l【-1】) # 14
5.2切片操作
l = 【10,11,12,13,14】
print(l【2:5】)
print(l【-3:-1】)
print(l【:3】)
print(l【1:】)
print(l【:】)
print(l【2:4】)
print(l【-3:-1】)
print(l【-1:-3】)
print(l【-1:-3:-1】)
print(l【::2】)
1、取出的元素数量为：结束位置 - 开始位置；
2、取出元素不包含结束位置对应的索引，列表最后一个元素使用 list【len(slice)】 获取；
3、当缺省开始位置时，表示从连续区域开头到结束位置；
4、当缺省结束位置时，表示从开始位置到整个连续区域末尾；
5、两者同时缺省时，与列表本身等效；
6、step为正，从左向右切，为负从右向左切。
5.3判断成员是否存在
in 关键字检查某元素是否为序列的成员
l = 【10,11,12,13,14】
print(20 in l) # False
print(12 in l) # True
5.4相加
l1 = 【1,2,3】
l2 = 【4,5,6】
print(l1+l2) # 【1, 2, 3, 4, 5, 6】
5.5循环列表
for name in 【"张三",'李四',"王五"】:
print(name)
for i in range(10): # range函数： range(start,end,step)
print(i)
# 基于for循环从100打印到1
for i in range(100,0,-1):
print(i)
==============================
6.列表
在实际开发中，经常需要将一组（不只一个）数据存储起来，以便后边的代码使用。列表就是这样的一个数据结构，python的列表可以存放不同的，任意的数据类型对象。
列表会将所有元素都放在一对中括号【 】里面，相邻元素之间用逗号,分隔，如下所示：
【element1, element2, element3, ..., elementn】
l = 【123,"yuan",True】
print(l,type(l))
# 注意
a,b = 【1,2】
print(a,b)
#序列操作
列表是 Python 序列的一种，我们可以使用索引（Index）访问列表中的某个元素（得到的是一个元素的值），也可以使用切片访问列表中的一组元素（得到的是一个新的子列表）。
【1,2,3,4,5】
0 1 2 3 4
-5 -4 -3 -2 -1
6.1索引求值
l = 【10,11,12,13,14】
print(l【2】) # 12
print(l【-1】) # 14
6.2切片操作
l = 【10,11,12,13,14】
print(l【2:5】)
print(l【-3:-1】)
print(l【:3】)
print(l【1:】)
print(l【:】)
print(l【2:4】)
print(l【-3:-1】)
print(l【-1:-3】)
print(l【-1:-3:-1】)
print(l【::2】)
1、取出的元素数量为：结束位置 - 开始位置；
2、取出元素不包含结束位置对应的索引，列表最后一个元素使用 list【len(slice)】 获取；
3、当缺省开始位置时，表示从连续区域开头到结束位置；
4、当缺省结束位置时，表示从开始位置到整个连续区域末尾；
5、两者同时缺省时，与列表本身等效；
6、step为正，从左向右切，为负从右向左切。
6.3判断成员是否存在
in 关键字检查某元素是否为序列的成员
l = 【10,11,12,13,14】
print(20 in l) # False
print(12 in l) # True
6.4相加
l1 = 【1,2,3】
l2 = 【4,5,6】
print(l1+l2) # 【1, 2, 3, 4, 5, 6】
6.5循环列表
for name in 【"张三",'李四',"王五"】:
print(name)
for i in range(10): # range函数： range(start,end,step)
print(i)
# 基于for循环从100打印到1
for i in range(100,0,-1):
print(i)
6.6列表内置方法
l = 【1,2,3】
方法 作用 示例 结果
append() 向列表追加元素 l.append(4) l：【1, 2, 3, 4】
insert() 向列表任意位置添加元素 l.insert(0,100) l：【100, 1, 2, 3】
extend(） 向列表合并一个列表 l.extend(【4,5,6】) l：【1, 2, 3, 4, 5, 6】
pop() 根据索引删除列表元素（为空删除最后一个元素） l.pop(1) l：【1, 3】
remove() 根据元素值删除列表元素 l.remove(1) l：【2, 3】
clear() 清空列表元素 l.clear() l：【】
sort() 排序（升序） l.sort() l：【1,2,3】
reverse() 翻转列表 l.reverse() l：【3,2,1】
count() 元素重复的次数 l.count(2) 返回值：1
index() 查找元素对应索引 l.index(2) 返回值：1
# 增删改查: 【】.方法()
# (1) ** 增(append，insert，extend) **
l1 = 【1, 2, 3】
# append方法：追加一个元素
l1.append(4)
print(l1) # 【1, 2, 3, 4】
# insert(): 插入，即在任意位置添加元素
l1.insert(1, 100) # 在索引1的位置添加元素100
print(l1) # 【1, 100, 2, 3, 4】
# 扩展一个列表：extend方法
l2 = 【20, 21, 22, 23】
# l1.append(l2)
l1.extend(l2)
print(l1) # 【1, 100, 2, 50, 3, 4,【20,21,22,23】】
# 打印列表元素个数python内置方法：
print(len(l1))
# (2) ** 删（pop，remove，clear） **
l4 = 【10, 20, 30, 40, 50】
# 按索引删除:pop,返回删除的元素
# ret = l4.pop(2)
# print(ret)
# print(l4) # 【10, 20, 40, 50】
# 按着元素值删除
l4.remove(30)
print(l4) # 【10, 20, 40, 50】
# 清空列表
l4.clear()
print(l4) # 【】
# (3) ** 修改(没有内置方法实现修改，只能基于索引赋值) **
l5 = 【10, 20, 30, 40, 50】
# 将索引为1的值改为200
l5【1】 = 200
print(l5) # 【10, 200, 30, 40, 50】
# 将l5中的40改为400 ,step1：查询40的索引 step2：将索引为i的值改为400
i = l5.index(40) # 3
l5【i】 = 400
print(l5) # 【10, 20, 30, 400, 50】
# (4) ** 查（index，sort） *
l6 = 【10, 50, 30, 20,40 】
l6.reverse() # 只是翻转 【40, 20, 30, 50, 10】
print(l6) # 【】
# # 查询某个元素的索引，比如30的索引
# print(l6.index(30)) # 2
# 排序
# l6.sort(reverse=True)
# print(l6) # 【50, 40, 30, 20, 10】
==============================
7.元组
Python的元组与列表类似，不同之处在于元组的元素只能读，不能修改。通常情况下，元组用于保存无需修改的内容。
元组使用小括号表示，声明一个元组：
(element1, element2, element3, ..., elementn)
需要注意的一点是，当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号,，否则 Python 解释器会将它视为字符串。
l = (1,2,3)
print(l,type(l)) # (1, 2, 3)
序列操作
7.1索引和切片
l = (1,2,3,4,5)
print(l【2】) # 3
print(l【2:4】) # (3, 4)
print(l【:4】) # (1, 2, 3, 4)
print(2 in l)
7.2内置方法
l = (1,2,3,4,5,3,3)
print(l.count(3)) #统计3的个数
print(l.index(5)) #查找首次5索引位置
==============================
8.字典
字典是Python提供的唯一内建的映射(Mapping Type)数据类型。
python使用 { } 创建字典，由于字典中每个元素都包含键（key）和值（value）两部分，因此在创建字典时，键和值之间使用冒号:分隔，相邻元素之间使用逗号,分隔，所有元素放在大括号{ }中。
使用{ }创建字典的语法格式如下：
1、同一字典中的各个键必须唯一，不能重复。
2、字典是键值对是无序的，但在3.6版本后，字典默认做成有序的了，这是新的版本特征。
dictname = {'key':'value1', 'key2':'value2', ...}
#字典的基本操作
8.1查键值
print(book【"title"】) # 返回字符串 西游记
print(book【"authors"】) # 返回列表 【'rain', 'yuan'】
8.2添加或修改键值对
注意：如果键存在，则是修改，否则是添加
book【"price"】 = 299 # 修改键的值
book【"publish"】 = "北京出版社" # 添加键值对
8.3删除键值对 del 删除命令
print(book)
del book【"publish"】
print(book)
del book
print(book)
8.4判断键是否存在某字典中
print("price" in book)
8.5循环
for key in book:
print(key,book【key】)
8.6字典的内置方法
方法 作用 示例 结果
get() 查询字典某键的值，取不到返回默认值 d.get("name",None) "yuan"
setdefault() 查询字典某键的值，取不到给字典设置键值，同时返回设置的值 d.setdefault("age",20) 18
keys() 查询字典中所有的键 d.keys() 【'name','age'】
values() 查询字典中所有的值 d.values() 【'yuan', 18】
items() 查询字典中所有的键和值 d.items() 【('name','yuan'), ('age', 18)】
pop() 删除字典指定的键值对 d.pop(“age”) {'name':'yuan'}
popitem() 删除字典最后的键值对 d.popitem() {'name':'yuan'}
clear() 清空字典 d.clear() {}
update() 更新字典 t={"gender":"male","age":20}d.update(t) {'name':'yuan','age': 20, 'gender': 'male'}
dic = {"name": "yuan", "age": 22, "sex": "male"}
# （1）查字典的键的值
print(dic【"names"】) # 会报错
name = dic.get("names")
sex = dic.get("sexs", "female")
print(sex)
print(dic.keys()) # 返回值：【'name', 'age', 'sex'】
print(dic.values()) # 返回值：【'yuan', 22, 'male'】
print(dic.items()) # 【('name', 'yuan'), ('age', 22), ('sex', 'male')】
# setdefault取某键的值，如果能取到，则返回该键的值，如果没有改键，则会设置键值对
print(dic.setdefault("name")) # get()不会添加键值对 ，setdefault会添加
print(dic.setdefault("height", "180cm"))
print(dic)
# （2）删除键值对 pop popitem
sex = dic.pop("sex") # male
print(sex) # male
print(dic) # {'name': 'yuan', 'age': 22}
dic.popitem() # 删除最后一个键值对
print(dic) # {'name': 'yuan'}
dic.clear() # 删除键值对
# (3) 添加或修改 update
add_dic = {"height": "180cm", "weight": "60kg"}
dic.update(add_dic)
print(dic) # {'name': 'yuan', 'age': 22, 'sex': 'male', 'height': '180cm', 'weight': '60kg'}
update_dic = {"age": 33, "height": "180cm", "weight": "60kg"}
dic.update(update_dic)
print(dic) # {'name': 'yuan', 'age': 33, 'sex': 'male', 'height': '180cm', 'weight': '60kg'}
# (4) 字典的循环
dic = {"name": "yuan", "age": 22, "sex": "male"}
# 遍历键值对方式1
# for key in dic: # 将每个键分别赋值给key
# print(key, dic.get(key))
# 遍历键值对方式2
# for i in dic.items(): # 【('name', 'yuan'), ('age', 22), ('sex', 'male')】
# print(i【0】,i【1】)
# 关于变量补充
# x = (10, 20)
# print(x, type(x)) # (10, 20)
# x, y = (10, 20)
# print(x, y)
for key, value in dic.items():
print(key, value)
==============================
9.集合
Python 中的集合，和数学中的集合概念一样。由不同可hash的不重复的元素组成的集合。
#声明集合
Python 集合会将所有元素放在一对大括号 {} 中，相邻元素之间用“,”分隔，如下所示：
{element1,element2,...}
其中，elementn 表示集合中的元素，个数没有限制。
从内容上看，同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型，否则 Python 解释器会抛出 TypeError 错误。
由于集合中的元素是无序的，因此无法向列表那样使用下标访问元素。Python 中，访问集合元素最常用的方法是使用循环结构，将集合中的数据逐一读取出来。
s = {"zhangsan",18,"male"}
for item in s:
print(item)、
s = {1,2,3,9}
print(s,type(s))
9.1去重功能
l = 【1,2,3,4,5,1】
s = set(l)
print(s)
new_l =list(s)
print(new_l)
9.2访问元素
for i in s
print(i)
9.3内置方法
方法 作用 示例 结果
add() 向集合添加元素 a.add(4) {1, 2, 3, 4}
update() 向集合更新一个集合 a.update({3,4,5}) | {1, 2, 3, 4, 5}` |
remove() 删除集合中的元素 a.remove(2) {1, 3}
discard() 删除集合中的元素 a.discard(2) {1, 3}
pop() 随机删除集合一个元素 a.pop() {2,3}
clear() 清空集合 a.clear() {}
intersection() 返回两个集合的交集 a.intersection(b) {3}
difference() 返回两个集合的差集 a.difference(b)b.difference(a) {1,2}{4,5}
symmetric_difference() 返回两个集合的对称差集 a.symmetric_difference(b) {1, 2, 4, 5}
union() 返回两个集合的并集 a.union(b) {1, 2, 3, 4, 5}
a = {1,2,3}
b = {3,4,5}
(1).添加元素
a.add(5)
print(a)
(2).更新元素
a.update({3,4,5})
print(a) #{1,2,3,4,5}
(3).删除元素
a.remove(6) #删除元素不存在报Key错误。
print(a)
a.discard(6) #删除元素不存在不报错。
a.pop
print(a) #随机删除一个元素
(4).交集
ret = a.intersection(b)
print(ret)
ret = b.intersection(a)
print(ret)
(5).并集
#a.update(b)
#print(a)
ret2 = a.union(b)
print(ret2)
ret2 = b.union(a)
print(ret2)
(6).差集
ret3 = a.difference(b)
print(ret3)
ret3 = b.difference(a)
print(ret3)
(7).对称差集
print(a.symmetric_difference(b))
print(b.symmetric_difference(a))
==============================
999.类型转换
i = int("3")
print(i,type(i)) # 3
s = str(3.14)
print(s,type(s)) # 3.14
'''
