目录
1、输出函数
print（）
1.1、数字：print（520）
1.2、字符串：print（“hello”） print（‘gdgdg’）
1.3、含运算符的表达式：print（3+1）
1.4、输出在文件中:
fd = open("text1.txt", "a+")
print("djhgfjwdhf", file=fd)
fd.close()
1.5、不进行换行：
print("dfsd","sdfsdf","sdfsdfsd")
2、转义字符
\n 换行 \t 四个空格 \r 回车 \b 退一格 \\\\ == \\ \' == ' \" == " 原字符： 不希望字符串中转义字符不起作用， 在字符串前加 r/ R 但是对后一个字符不能是 一个 \ ，两个可以 printf(r"jyfjyfjfg\tjgjhgj")
3.1 二进制与字符编码
unicode 英文、中文 两个字节
utf-8 英文一个字节 、中文3个字节
print(chr(38472))
print(ord("陈"))
3.2标识符和保留字
3.1.1、查看保留字
import keyword
print(keyword.kwlist)
3.1.2、
字母、下划线、数字
不能使用数字开头
严格区分大小写
不能使用保留字
3.3变量定义及使用
id（） 获取地址 type（）获取类型
3.3.1 变量的多次赋值
多次赋值后，变量名会指向新的空间
4、数据类型
整数 int 浮点型 float 布尔类型 bool
4.1 整数
英文integer ，简写int 可以表示正数 、负数和零 十进制 默认的进制 二进制 以0b开头 八进制 以0o开头 十六进制 以0x开头
4.2浮点类型
浮点存储不精确
导入模块decmal
from decimal import Decimal
print(Decimal("1.1") + Decimal("2.3"))
4.3 布尔类型
Ture 真 =》 1 False 假 =》 0 可以直接当成1、0用
4.4 字符串类型
不可变的字符序列 可以使用 单引号、双引号 、三引号 。前两者必须在一行， str1 = 'nihao' print(str1, type(str1)) str1 = "nihao" print(str1, type(str1)) str1 = '''nihaod fdfsdfd sddddddddddddd\nddddddddsfds''' print(str1, type(str1))
4.5 数据类型转换
name = "zhangsan"
age = 20
print(type(age), type(name))
print("wojiao "+name+"year"+str(age))
str（）转为字符串
int（）转为整型
文字类和小数类字符串，无法转换为整数。浮点类型转换为抹零取整
float（）转为浮点型
文字类无法转换，整数转浮点型，末尾加.0
a = 10
b = 198.2
c = False
print(type(a), type(b), type(c))
print(str(a), str(b), str(c))
print(int(a), int(b), int(c))
print(float(a), float(b), float(c))
5、注释
coding：utf-8 首行表示文件编码存储模式 单行注释：以# 开头 直到换行 多行注释 ：''' ''' 没有赋值变量就是注释
6、输入
input（）
7、运算符
7.1算术运算符
print(1+1) print(1-1) print(1*1) print(11/2) print(11//2) #整除 print(11%2) print(11**2) #11的2次方 print(-9//-4) #整除时，一正一负，向下取整 print(-9//4) #-3 print(9//-4) #-3 #公式：余数= 被除数 -除数*商 print(9%-4) #-3 9 - (-4)*(-3) = -3 print(-9%4) #3 -9 - （4）*（-3） = 3
7.2 赋值运算符
从右向左执行
a = 3+4
链式赋值：a=b=c=3
支持解包赋值: a,b,c=12,5,8
a ,b = 10,20
交换
a,b = b,a
7.3 比较运算符
比较运算的结果就是bool类型，rure或false 比较对象的标识用的是 is a=10 b=10 print(a is b) true liat1 =[11,22,33,44] liat2 =[11,22,33,44] print(liat2==liat1) true print(liat2 is liat1) false 标识不等： is not
7.4布尔运算符
1、and 与
2、or 或
3、not 取反
4、in 在什么里
print("h" in "hello") true
print("s" in "hello") fasle
5、not in
8.1 对象的布尔值
bool（）求布尔值 1、false 2、数值0 3、none 4、空字符串 5、空列表 6、空元组 7、空字典 8、空集合
8.2 结构语句
if 条件表达式 ：
条件执行
if 条件表达式 ：
条件执行1
else：
条件执行2
if 条件表达式1 ：
条件执行1
elif 条件表达式2 ：
条件执行2
代码1 if 条件判断 else 代码2
条件成立 执行代码1 ，否则执行代码2
8.3 pass语句
pass语句，什么都不做。只是一个占位符，用到需要写语句的地方
if ass== “y”：
pass
else：
在这里是为了不让报错，又保证了语法结构
8.4 循环语句
1、 range（）函数
生成一个整数序列
2、使用的三种方式
range（stop）： 创建一个（0，stop）之间的整数序列，步长为1
range（start，stop）：创建一个（sart，stop）之间的整数序列，步长为1
range（sart，stop，step）：创建一个（sart，stop）之间的整数序列步长为step
3、返回值是一个迭代器对象
while 条件表达式：
条件执行体
for 自定义变量 in 可迭代对象（字符串、序列（range））：
循环体
for ——（下划线） in range（5）
print（“dsfsdf”）
执行五次不关心变量
8.5 else 语句
可以和while for搭配，如果循环中没有break就会执行else。循环正常结束，没有只有break就会执行else。
for itom in range(3):
pwd = input("mima")
if pwd == "8888":
print("success")
break
else:
print("failed")
else:
print("三次密码错误")
a =0
while a<3:
pwd = input("mima\n")
if pwd == "8888":
print("success")
break
else:
print("failed")
a +=1
else:
print("三次密码错误")
9 列表
1、列表可以看成其他语言的数组
2、列表中的元素可以是任意类型
创建：
1、a = [1,"2",2,3]
2、a = list（[1,"2",3,3]）==》内置函数
3、特点
3.1、索引（下标）：
从左到右，从0开始
从右到左，从-1开始
3.2、列表可以存储重复数据
3.3、任意数据类型可以混存
3.4、根据需要自动动态分配和回收内存
4、列表元素的查询
4.1、由元素本身的值在列表中找索引值
list.index("元素") 返回该元素在列表第一次出现的位置索引
lst = ["hello", "wrod", 89, "hello"]
print(lst.index("hello"))
在指定位置查找：在列表[1,4)区间类查找“hello”，并返回索引值
lst = ["hello", "wrod", 89, "hello"]
print(lst.index("hello", 1, 4))
4.2、由索引值找具体元素值
4.2.1 正向索引：列表n个元素，从[0,n-1]，对应具体的元素
4.2.2 反向索引：列表你n个元素，[-n,-1],对应具体元素
4.3 获取多个列表中的元素：切片
4.3.1 列表名[sart:stop:step]
4.3.2 切片结果：源列表片段的拷贝
4.3.3 切片范围：[sart:stop]
4.3.4 step 默认为1
4.3.5 step为正数：
[:stop:step] 切片第一个元素默认为列表第一个元素
[start::step] 切片最后一个元素默认为列表最后一个元素
4.3.6 step为负数
[:stop:step] 切片的第一个元素是列表的最后一个元素
[start::step] 切片最后一个元素是列表第一个元素
list = [12, 34, 56, 51, 63, 72, 656, 8, 86, 9, 89, 8, 7]
print(list[:13])
print(list[-1:-5:-1])
print(list[::-1]) 逆序列表
5、 判断元素是否在列表中存在： in（是否存在） ；not in（是否不存在）
6、遍历列表元素：用for循环
7、列表元素的增加
7.1 向列表末尾添加一个元素：append（）
7.2 向列表末尾至少添加一个元素：两列表相加 或者 extend（）
7.2.1 list.append(list2)：把列表二作为一个元素添加在列表末尾
7.2.2 list+ list2 /list.extend(list2):把列表二拼接到列表1后面
7.3 在列表任意位置添加一个元素：insert（）
list.insert（1，90） 在列表索引值为1 的位置添加90.其他元素自动后移
7.4 在列表任意位置添加至少一个元素 ：切片
list[1:2] = list2
list1 = [1, 2, 3, 4, 5, 6, 7, 8]
list2 = ["11", "22", "33"]
list1[1:1] = list2 在位置1 插入list2，原list1位置1元素不变
print(list1)
list1[0:1] = list2 把0切后插入list1，原list1位置0元素删除
print(list1)
8、列表中删除元素
8.1 remove（）：一次删除一个元素；重复元素只删除第一个；元素不存在会抛出异常（valueerror）
list = [1, 2, 2, 34, 5, 6, 7, 8, 9, 12, 3, 4, 4]
list.remove(2) 删除元素值为2的第一个元素
8.2 pop（）：删除一个指定索引位置的元素；指定索引不存在抛出异常（indexerror）；不指定索引，删除列表中最后一个元素
list = [1, 2, 2, 34, 5, 6, 7, 8, 9, 12, 3, 4, 4]
list.pop(0) 删除索引为0的元素
8.3 切片： 一次至少删除一个元素；会产生一个新的列表对象
list = [1, 2, 2, 34, 5, 6, 7, 8, 9, 12, 3, 4, 4]
list2 = list[1::1] 把索引为1到末尾全切出来形成一个新列表。对于新列表，就是在源列表基础上删除了索引为0的元素
print(list)
print(list2)
方法二：用空列表替代
list[1:3] = []
把[1,3)这之间的两个元素用空列表替换，就删除了原列表索引为1、2的元素
8.4 清楚列表中所有元素：clear（）
8.5 删除列表对象： del（）
9、修改列表元素
通过索引值改：list[0] =89 ;将列表索引为0的位置上数据换成89
10、列表排序
10.1 调用sort（）
list1.sort（） 默认升序排序
list1.sort(reverse=True) 降序
list1.sort(reverse=False) 升序
10.2 调用sorted（）；原列表不变，会产生一个新列表
list1 = [1, 2, 2, 34, 5, 6, 7, 8, 9, 12, 3, 4, 4]
print(list1, id(list1))
list2 = sorted(list1，reverse=False) 产生一个升序新列表
11、 列表生成式
list1 = [i*i for i in range(1, 10)] list1 = [i for i in range(1, 10)]
12、字典
1、与列表一样是一个可变序列（可以进行增删改查等操作）
2、以键值对的方式存储数据，字典是一个无序的序列
3、创建字典：
3.1 a ={34:12, 341:56};使用花括号
3.2 a =dict（name=“hfh”， age=45）；使用内置函数
4、从字典中获取数据
4.1 字典名[key]；如果字典中没有key 会抛出异常keyerror
4.2 字典名get(key)；如果字典中没有key 不会抛出异常,输出None
get（key，99）；当key不存在时，会返回自己设置的默认值：99
5、key的判断（in ；not in），返回ture 或false
6、删除指定的键值队：del【key】
7、清空字典：字典名clear（）
8、添加一个元素：字典名【新key】 = 具体值
9、修改一个元素：字典名【已存在key】 = 具体值
13、字典的试图操作
1、keys（） 获取字典中所有key ，返回值为dict——keys类型，通过list（）函数转换为列表 2、values（） 获取字典中所有value，返回值为dict——values类型，通过list（）函数转换为列表 3、items（） 获取字典中所有key，value队，返回值为dict——items类型，通过list（）函数转换为列表，每一个元素由元组组成。
14、字典元素的遍历
for i in 字典名
print（i） 打印的是每个key
print（字典名【key】）
15、字典的特点
1、字典中的所有元素都是一个key-value队，key不允许重复，value可以重复 2、字典中的元素的无序的 3、字典中的key必须是不可变对象（数字、字符串） 4、字典也可以根据需要动态的伸缩 5、字典会浪费较大的内存，是一种使用空间换时间的数据结构
16、字典生成式
zip（）
由两个列表生成一个字典，items列表元素 作为key， pricen列表元素作为值。两个列表元素个数不一致时，以较少的列表为标准。upper()函数是将字符串变为大写
items = ["freuir", "books", "othras"]
pricen = [56, 78, 23]
d = {i.upper(): j for i, j in zip(items, pricen)}
print(d)
输出结果： {'FREUIR': 56, 'BOOKS': 78, 'OTHRAS': 23}
17、元组
元组是一个不可变序列
不可变序列：字符串、元组。没有增删改的操作
可变序列：列表、字典。可以对序列进行增删改操作，对象地址不发生更改
元组与列表用法相识。列表用【】，元组用（）。列表是可变序列，可以增删改。元组是不可变序列，不可以进行增删改操作。
1、创建
t1 = (12, 34, 455, 5, 65, 65)
t2 = tuple(("we", "ew", 32, 43, 6))
****只含有一个元素的元组，后面有一个逗号
t= （12，）
2、
空列表： lis = 【】 ； lis = list【】
空字典： d = {} ; d=dict{}
空元组： t = () ;t= tuple()
*****************
1、为什么要把元组设计成不可变序列：
对于共享资源的保护可以用锁，保证同一时间只有一个进程操作数据。元组是从另一个方向对共享资源的保护，直接规定元组不可变，多个进程可以查看但是不能修改，这样就保护了共享资源。
2、元组中存储的是对象的引用。
3、不管元组的元素是可变还是不可变，其引用都不可以再去引用其他对象。既，元组确定后，引用不可变。
如果其元素是可变序列，如：列表、字典。虽然不能将当前引用改为其他列表、字典。但是对于可变序列中的内容可以增删改操作。
t = (1, [12, 13], 34)
print(t)
# t[0] = 13 改变引用方向，报错
# t[1] = [12,45] 改变引用方向，报错
# t[1] = 12 改变引用方向，报错
t[1][0] = 234 改变元组元素（列表，可变序列）中的数据。可以
tt[1].append(123) 改变元组元素（列表，可变序列）中的数据。可以
print(t)
版权声明：本文为x844049168原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。