1.print（）
可以输出数字print(520)
可以输出字符串print('hello word')
含有运算符的表达式print(3+1)#会计算表达式的结果
将数据输出到文件中
fp=open('D:/text.txt','a+')#a+以读写的方式打开文件,a+如果文件不存在就创建，存在就打开继续追加
print('Hello world',file=fp)#要使用file=fp
fp.close()#关闭
不进行换行输出（输出内容在一行当中）
print("hello","world","HFF")
2.转义字符
转义字符就是：反斜杠+想要实现的转义功能首字母
换行n 回车r 水平制表符t 退格b
print("hello nworld")
print("hello tworld")#四个字符一个表格 0_ ＿ ＿
print("helloooo tworld")#＿ ＿ ＿ ＿ 看＼ｔ之前是否占满制表位，占满就重新开一个，没占满接着用
print("hellorworld") #回车，world把hello覆盖掉了
print('hellobworld')#退一个格，把o退掉了
\第一个斜线是反斜线，第二个相当于转义字符但又不是
print("http:\www.baidu.com")
http:www.baidu.com#少了一个斜线
print(http:\\www.baidu.com)
http:\www.baidu.com#两个\会转出一个
print(”老师说:"大家好"")
"表示这不是”不再是字符串的边界而是 字符串中应该输出的内容
原字符，不希望字符串中的转义字符起作用，就是在字符串之前加上r或R
print(r"hellonworld")#最后一个字符不能是反斜杠 print(r"hellonworld\")#两个可以
3.二进制与字符编码
8个位置(bit）为一个字节，1024个字节等于1KB（千），1024KB=1MB（兆），1024MB=1GB（吉）1024GB=1TB（太）
print(chr(0b100111001011000))#乘 0b-二进制 print（ord（乘））#0rd十进制
4.标识符和保留字
严格区分大小写
import keyword print(keyword.kwlist)#查看保留字
5.变量的定义和使用
变量由三部分组成：
标识：表示对象所存储的内存地址，使用内置函数id(obj)来获取
类型：表示的是对象的数据类型，使用内置函数type(obj)来获取
值：表示对象所存储的具体数据，使用print(obj)可以将值进行打印输出
name='懒羊羊' print(name) print('标识'，id(name)) print('类型'，type(name)) print('值'，name)
6.变量的多次赋值
多次赋值以后，变量名会指向新的空间，原来name id指向的空间变成了内存垃圾
name='懒羊羊' name='灰太狼' print(name)
7.数据类型
整数类型——>int——>100
浮点数类型——>float——>3.14156
布尔类型——>bool——>True,False
字符串类型——>str——>'朝闻道，夕死可矣'
8.整数类型十进制——默认进制,取值0-9
二进制——以0b开头，取值0-1
八进制——以0o开头，取值0-7
十六进制——以0x开头，取值0-9和A-F
print('二进制'，0b10101111)
9.浮点类型
浮点数存储不精确性
使用浮点数进行计算时，可能会出现小数位数不确定的情况
n1=1.1 n2=2.2 print(n1+n2)
解决方案：导入模块decimal
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))
10.布尔类型
布尔值可以转化为整数
True——1
False——0
f1=False print(f1+1)#直接转11.字符串类型
字符串又称不可变的字符序列
可以使用单引号，双引号，三引号来定义
单引号和双引号定义的字符串必须在一行
三引号定义的字符串可以分布在连续的多行
str1='朝闻道，夕死可矣'
str2="朝闻道，夕死可矣"
str3="""朝闻道，
夕死可矣"""
12.数据类型转换
将不同数据类型的数据拼接在一起
str() int() float()
name='懒羊羊'
age=8
print('我叫'+name+'今年'+str(age)+'岁')
int() 1.文字类和小数类字符串，无法转化成整数 2.浮点数转成整数，抹0取整
float() 1.文字类无法转成浮点型，2.整数转为浮点型，末尾会加.0 3.小数类字符串可以转
13.注释
单行注释：以#开头，直到换行结束
多行注释：并没有单独的多行注释标记，将一对三引号之间的代码称为多行注释，不赋值给任何变量
中文编码声明注释：在文件开头加上中文声明，用于指定源码文件的编码格式
print('hello')
"""
我是懒羊羊，
我爱吃青草蛋糕
"""
python默认的存储编码是utf-8
#coding:gbk """ 我是懒羊羊， 我爱吃青草蛋糕 """
用记事本打开，另存为可以看到改为了
14.input函数的使用
作用：接收来自用户的输入·,结果是一个str类型
present=input('懒羊羊想要什么礼物呢？')
print(present)
#从键盘中输入两个整数，计算两个整数的和
a=input('请输入一个加数:')
a=int(a)
b=input('请输入另一个加数:')
b=int(b)
print(a+b)
print('-'*30)
a=int(input('请输入一个加数:'))
b=int(input('请输入另一个加数:'))
print(a+b)
15.运算符——算术运算符
标准算术运算符——加（+），减（-），乘（*），除（/），整除（//）
取余运算符——%
幂运算符——**
print(9//-4)#结果为-3,一正一负整除，向下取整 print(-9%4) # 3 -9-4*(-3) print(9%-4) #-3 9-（-4）*（-3） """ 余数=被除数-除数*商 """
16.赋值运算符
= 执行顺序：从右到左
支持链式赋值——a=b=c=20 #将20赋给 a,b,c,a=20,b=20.c=20
支持参数赋值——+=，-=，*=，/=，//=，%=
a=20 a+=30 #相当于a=a+30 print(a) #50 a-=10 #相当于a=a-10 print(a) #40 a*=2 #相当于a=a*2 a/=3 #相当于a=a/2 a//=2 #相当于a=a//2
支持系列解包赋值——a,b,c=20,30,40 a=20,b=30,c=40#等号左右个数相同都是3个
#交换两个变量的值 a,b=10,20 a,b=b,a
17. 比较运算符
对变量或表达式的结果进行大小，真假等比较;比较运算符的结果为bool类型
> ,< , >= , <=, !=
== “一个等号称为赋值运算符，两个等号称为比较运算符”
一个变量由三部分组成：标识，类型，值
== 比较的是值
比较对象的标识使用 is
a=10 b=10 print(a==b) #True 说明a与b的值相等 print(a is b) #True 说明a与b的ID标识相等 lst1 = [11,22,33,44] lst2 = [11,22,33,44] print(lst1==lst2) #true print(lst1 is lst2) #falseis not ID是不相等的
18.布尔运算符
对于布尔值之间的运算
and or not in not in
and 两个都是真，结果才为真
or 只要有一个为真，结果就为真
not 取反
f=True print(not f)
in 在不在当中
s='hello world'
print('w' in s)
print('K' not in s)
19.位运算符
将数据先转成二进制再进行计算
位与&——>对应位数都是1，结果数位才是1，否则为0
位或|——>对应位数都是0，结果数位才是0，否则为1
左移位运算符<< 高位溢出舍弃，低位补0
右移位运算符<< 低位溢出舍弃，高位补0
print(4<<1) #向左移动一个位置，相当于乘以2 print(4<<2) #向左移动两个位置 print(4>>1) #向右移动一个位置，相当于除以2 print(4>>2) #向右移动两个位置，相当于除以4
20.运算符的优先级
**
*，/，//，% 算术运算符：先算乘除再算加减，有幂最先
+，-
>> ,<<
& 位运算
I
> ,< ,>=,<=,==,!= 比较运算符 ：结果true或者false
and
or 布尔运算
= 赋值运算
21.顺序结构
程序的组织结构：顺序结构，选择结构，循环结构
顺序结构：程序从上到下顺序的执行代码，中间没有任何的判断和跳转，直到程序的结束
22.对象的布尔值
python一切皆对象，所有的对象都有一个布尔值
获取对象的布尔值: 使用内置函数bool()
以下对象的布尔值为false
false 数值0 none 空字符串 空列表 空元组 空字典 空集合
#测试对象的布尔值
print(bool(False))
print(bool(0.0))
print(bool(None))
print(bool([])) #空列表【】
print(bool(list())) #空列表list（）
print(bool(())) #空元组（）
print(bool(tuple())) #空元组tuple()
print(bool({})) #空字典｛｝
print(bool(dict())) #空字典dict()
print(bool(set())) #空集合
其他对象的布尔值均为True
age=int(input("请输入你的年龄"))
if age:
print(age)
else:
print("年龄为：",age)
23.分支结构
单分支结构
if 条件表达式：
条件执行体
money=1000 #余额
s=int(input('请输入取款金额')) #取款金额
#判断余额是否充足
if money>=s:
money=money-s
print('取款成功，余额为：',money)
双分支结构
if 条件表达式：
条件执行体1
else：
条件执行体2
#双分支结构
"""
从键盘录入一个整数，编写程序让计算机去判断是奇数还是偶数
"""
n=int(input("请输入一个整数"))
if n%2==0
print(n,'这是一个偶数')
else:
print(n,"这是一个奇数")
多分支结构
if 条件表达式1：
条件执行体1
elif 条件表达式2：
条件执行体2
elif 条件表达式N：
条件执行体N
[else:]
条件执行体N+1
"""多分支结构，多选一执行
从键盘录入一个整数成绩
90-100 A
80-89 B
70-79 C
60-69 D
0-59 E
大于100或小于0 非法
0
"""
score=int(input("请输入一个成绩："))
#判断
if 90<=score<=100 #python中可以这样写
print('A级')
elif score >=80 and score<=89
print("B级")
elif score >=70 and score<=79
print("C级")
elif score >=60 and score<=69
print("D级")
else
print("非法")
嵌套IF
语法结构：
if 条件表达式1：
if 内层条件表达式：
内存条件执行体1
else
内存条件执行体2
else：
条件执行体
answer=input("您是会员吗?y/n")
money=float(input("请输入你的购物金额："))
if answer=='y' : #会员
print("会员")
if money>=200:
print("打八折，付款金额为：",money*0.8)
elif money>=100:
print("打九折，付款金额为：",money*0.9)
else:
print("不打折，付款金额为：",money)
else： #非会员
print("非会员")
if money>=200:
print("打九五折，付款金额为：",money*0.95)
else
print("不打折，付款金额为：",money)
24.条件表达式
条件表达式是if.....else的简写
语法结构.
x if 判断条件 else y t条件执行正确，往前运行，错误往后运行
运算规则
如果判断条件的布尔值是True，条件表达式的返回值为x,否则条件表达式的返回值为False
"""
从键盘录入两个整数，比较两个整数的大小
"""
num_a=int(input('请输入第一个整数'))
num_b=int(input('请输入第二个整数'))
#比较大小
if num_a>=num_b:
print(num_a,"大于等于",num_b)
else:
print(num_a,'小于',num_b)
print('+'*30)
#使用条件表达式
print( print(num_a,"大于等于",num_b) if num_a>=num_b else (num_a,'小于',num_b) )
print( print(str(num_a)+"大于等于"+str(num_b) if num_a>=num_b else ....)
25.pass语句
语句什么都不做，只是一个占位符，用在语法上需要语句的地方
什么时候用：先搭建语法结构，还没想好代码怎么写的时候
if语句的条件执行体
for——in语句的循环体
定义函数时的函数体
answer=input("您是会员吗?y/n")
money=float(input("请输入你的购物金额："))
if answer=='y' : #会员
pass
else： #非会员
pass
26.range函数
range(stop):创建一个[ 0,stop)之间的整数序列，步长为1
range(start,stop):创建一个[ start,stop)之间的整数序列，步长为1
range(start,stop,step):创建一个[ start,stop)之间的整数序列，步长为step
返回值是一个迭代器对象
r=range(10) print(r) #range(0,10)查看不了 print(list(r)) #用于查看range对象中的整数序列
range的优点：不管range对象表示的整数序列有多长，所有的range对象占用的内存空间都是相同的，因为仅仅需要存储star，stop和step，只有当用到range对象时，才会去计算序列中的相关元素
in 和not in 判断整数序列中是否存在（不存在）指定的整数
r=range(1,10,2) print(10 in r)
27.循环结构
while 条件表达式:
循环体（条件执行体）
当条件表达式的值为False的时候，退出循环
while是判断N+1次，条件为True执行N次
if是判断一次，条件为True执行一次
四布循环法：初始化变量 条件判断 条件执行体（循环体） 改变量
#计算1:10之间的累加和
"""初始化变量"""
a=0
sum=0
"""条件判断"""
while a<11
"""条件执行体"""
sum+=a
"""改变变量"""
a+=1
print("和为：",sum)
for-in循环
for 自定义的变量 in 可迭代对象：
循环体
in ——表示从（字符串，序列等）中依次取值，又称遍历
for-in遍历的对象必须是可迭代对象
for item in "Python": # p y t h o n
print(item)
range()产生一个整数序列，也可以是一个迭代对象
for i in range(10):
print(i)
如果在循环体中不需要使用带自定义变量，可以将自定义变量写为''_''
for _ in range(5):
print('救命啊，喜羊羊') #救命啊，喜羊羊将运行五次
"""
输出100到999之间的水仙花数
举例：
153=3*3*3+5*5*5+1*1*1
***
for item in range(100,1000)
ge=item%10
shi=item//10%10 #多看看
bai=item//100
#print(ge,shi,bai)
if ge**3+shi**3+bai**3==item
print(item)
流程控制语句——break
用于结束循环结构，通常与分支结构if 一起使用
""" 从键盘录入密码，最多录入三次，如果正确就结束循环 """
for item in range(3):
pwd=input("请输入密码")
if pwd='8888'
print('密码正确')
break
else:
print('密码不正确')
a=0
while a<3:
pwd=input("请输入密码：")
if pwd='8888'
print('密码正确')
break
else:
print('密码不正确')
"""改变变量"""
a+=1
continue
用于结束当前循环，进入下一次循环，通常与分支if一起使用
""" 要求输出1到50之间的所有5的倍数"""
for item in range(1,51)
if item%5==0
print(item)
for item in range(1,51)
if item%5!=0
continue
print(item)
28.else语句
else可以和if,while ,for搭配
for/while.....
....
else：
...
没有碰到break时执行else
for item in range(3):
pwd=input("请输入密码：")
if pwd=='8888'
print("密码正确")
break
else:
print("密码不正确")
else:
print ("对不起，三次密码均输入错误")
29.嵌套循环
在循环结构中又嵌套了另外的完整的循环结构，其中内层循环作为外层循环的循环体执行,
外层循环一次，内层循环一轮
"""输出一个三行四列的矩阵 """
for i in range(1,4) : #行数
for j in range(1,5):
print('*',end='t') #不换行输出
print() #打行
#9*9乘法表，第一行一个，第二行两个
for i in range(1,10):
for j in range(1,i+1):
print(i'*'j,'=',i*j,end='t')
print()
30.二重循环中的break和continue
二重循环中的break和continue用于控制本层循环
""" 流程控制语句break与continue在二重循环中的使用"""
for i in range(5): #代表外层循环要执行五次
for j in range(1,11):
if j%2==0:
break
print(j，end="t")
#结果
1
1
1
1
1
31.列表
变量可以存储一个元素，而列表是一个“大容器”可以存储N多个元素，程序可以方便地对这些数据进行整体操作
变量存储的是一个对象的引用（id）
list=['hello','world',98]
32.列表的创建列表需要使用中括号【】，元素之间使用英文的逗号进行分隔
lst = ['l懒羊羊','喜欢','睡觉']
使用内置函数list()
lst2=list(['helo','world',98])
列表对象——赋给lst2 =id 987
ide:987 type:list value:'helo','world',98
列表的特点：
列表元素按顺序有序排列
索引映射唯一的数据
列表可以存储重复数据
任意数据类型混存
根据需要动态分配和回收内存——不用担心列表不够用
print(lst2[0],lst2[-3])
列表的查询操作
如果列表中存在N个相同元素，只返回相同元素中的第一个元素的索引
如果查询的元素在列表中不存在，则会抛出ValueError
还可以在指定的start和stop之间进行查找
lst=['hello','world',98,'hello']
print(lst,index('hello'))
print(lst,index('python'))
print(lst,index('hello',1,3)) #在'world',98,没有hello会报错
print(lst,index('hello',1,4)) #3
33.切片操作——获取列表中的多个元素
列表名[start:stop:step]
切片的结果：原列表片段的拷贝
切片的范围：[start,stop)
step默认为1 start默认是0 stop默认是最后一个元素（包含最后一个）
lst = [10,20,30,40,50,60,70,80] print(lst[0:7]) print(lst[0::1]) """ [10, 20, 30, 40, 50, 60, 70] [10, 20, 30, 40, 50, 60, 70, 80] """
lst = [10,20,30,40,50,60,70,80] print(lst[1:6:1]) #[20 30 40 50 60] print(lst[1:]) #[20 30 40 50 60 70 80]
切出来的是一个新的列表对象，ID不一样
step为负数，逆序
lst = [10,20,30,40,50,60,70,80] print(lst[::-1]) #[80,70,60,50,40,30,20,10] print(lst[7::-1]) #[80,70,60,50,40,30,20,10] print(lst[6:0:-2]) #[70,50,30]
判断指定元素在列表中是否存在
lst=[10,20,'python','hello']
print(10 in lst)
print(10 not in lst)
列表元素的遍历
lst = [10,20,30,40,50,60,70,80]
for item in lst:
print(item)
34.列表元素的增加操作
增加操作：
append() :在列表的末尾添加一个元素
extend() :在列表的末尾至少添加一个元素
insert() ：在列表的任意位置添加一个元素
切片 ：在列表的任意位置添加至少一个元素
lst = [10 ,20 ,30] lst.append(100) #[ 10, 20, 30, 40],增加后的列表和原列表标识（ID）相同 lst2=['heelo','world'] lst.extend(lst2) #[10 ,20 ,30,'heelo','world'] lst=[10 ,20 ,30,'heelo','world'] lst.insert(1,90) #[10,90,20 ,30,'heelo','world'] lst=[10,90,20 ,30,'heelo','world'] lst3=[True,False,'hello'] #[10,True,False,'hello'] 切掉的部分用一个新的列表替换 lst[1:]=lst3 #从90开始切
35.列表元素的删除操作：
remove() :一次删除一个元素 重复元素只删除第一个 元素不存在抛出ValueError
pop() :删除一个指定索引位置上的元素 指定索引不存在抛出ValueError，不指定索引，删除列表中最后一个元素
切片：一次至少删除一个元素
clear():清空列表
del 删除列表
lst = [10,20,30,40,50,60,30] lst.remove(30) print(lst) lst.remove(3000) print(lst) lst = [10,20,30,40,50,60,30] lst.pop(1) lst.pop(10000) lst.pop() #切片，切片将会产生一个新的列表对象 lst=[10,40,50,60] new_list=lst[1:3] #切片后的列表[40,50] """切片：不产生新的列表对象，而是删除原列表的内容""" lst[1:3]=[] print(new_list) lst.clear() print(lst) #[] 清除列表中的所有元素 '''del语句将列表对象删除''' del lst print(lst) #没有定义
36.列表元素的修改
为指定索引的元素赋予一个新值
为指定的切片赋予一个新值
lst=[10,20,30,40] lst[2]=100 #[10,20,100,40] lst[1:3]=[300,400,500,600] #[10,300,400,500,600,40]37.列表元素的排序操作
sort() ：默认从小到大的顺序进行排序，也可以指定reverse=True，进行降序排序，排序是在原列表上进行的
sorted() :可以指定reverse=True，进行降序排序,原列表没有产生变化，而是产生了一个新的列表
lst=[20,40,50,10,98,5]
print("排序前的列表",lst,id(lst))
#开始排序
lst.sort() #等同 lst.sort(reverse==False)
print('排序后的列表',lst,id(lst)) #id没变，排序是在原列表上进行的
#指定关键字参数，进行降序排序
lst.sort(reverse==True)
print('排序后的列表',lst,id(lst)) #id没变，排序是在原列表上进行的
#使用内置函数sorted()对列表进行排序，将产生一个新的列表
lst=[20,40,50,10,98,5]
new_list=sorted(lst)
print(lst) #原列表没有产生变化，而是产生了一个新的列表
print(new_list)
#降序排列
desc_list=sorted(lst,reverse=True)
38.列表生成式
列表生成式简称：“生成列表的公式”
语法格式：
[ i *i for i in range(1,10)]
i*i:列表元素的表达式，列表中真正包含元素的值
lst=[i for i in range (1,10) ] lst=[i*i for i in range (1,10) ] lst=[i*2 for i in range (1,6) ]39.字典
字典与列表一样是一个可变序列【可以增删改】
以键值对的方式存储数据，字典是一个无序的序列 键：值
列表【】 字典｛ ｝
第一个放入字典中的，不一定在字典中处于第一个位置，所以说它无序
hash(key)——>，把键放到hash（哈希函数）中进行计算得到的位置，放到字典中的键必须是不可变序列，不可变序列作为键的时候不管怎么动哈希值计算出来都是相同的。
整数序列和字符串序列都是不可变序列
字典的实现原理：与查字典类似，查字典是先根据部首或拼音查找相应的页码，python中的字典是根据key查找value所在位置
hash(key)——>value所在的位置
40.字典的创建最常用的方式：使用花括号
scores=｛'懒羊羊':0 , '喜羊羊':100｝
使用内置函数dict()
dict(name='jack',age=20)
dict(name='懒羊羊',age=8) #等号左侧是键，等号右侧是值
空字典d={}
41.字典的增删改key的判断 in：指定的key在字典中存在返回True
not in：指定的key在字典中不存在存在返回True
"""
键的判断
"""
scores={"懒羊羊":0,'喜羊羊':100}
print("懒羊羊" in scores)
字典元素的删除
""" 字典元素的删除 """ del scores=['喜羊羊']
scores['美羊羊']=80 #新增元素
scores['美羊羊']=90 #修改元素
scores.clear() #清空字典的元素
42.字典的视图操作keys():获取字典中所有key
values():获取字典中所有Value
items():获取字典所有key,value对
keys=scores.keys() #字典键类型 print(list(keys))#将所有的key组成的视图转化为列表 values=scores.values() #字典值类型 print(list(values)) items=scores.items() print(list(items))#列表中的每一个元素都是一个元组（‘懒羊羊’，100）
