# 两周内搞定
# 第一遍快阅
# 第二遍认真读
""" 第一章 + 第二章
#在python中 单引号 双引号没有区别
fp=open('D:/text.txt','a+') #一定要赋值给变量，银锭要写盘符路径，一定要写a+
print('hello','world','python',file=fp) #一定要把文件变量赋值给file
fp.close() #结束文档流，running几次，在文件中写几次
print('hello','world','python') #单行书写
print('abcdabcdabcd')
print("abcdab\tabce") #\t空格部位符号，一般是4个空格，
#\r回车符 覆盖作用
#\b退格符，删掉一个格
#\n另起一行 newline
#\\输出一个\
#\'输出一个单引号
#\"输出一个双引号
print(r'hello\nworld') ## r 或 R 使转义字符失效，但是结尾 反斜杠 个数必须是双数
print(r"hello\nwlkdl\\\\\\")
print(0b101) #二进制转10进制
print(chr(0b01000001)) ##十进制转字符串
print(ord('A')) #字符串转十进制编码
print(0b1010) #0b开头二进制
print(0o147) #0o开头八进制
print(0x165EA9)#0x开头十六进制
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))
# —————————————————————————————————————————————————— 练习——————————————————————————————————————————
from decimal import Decimal
print(Decimal('1.1')+Decimal('2.2'))
wode=open('D:/text2.txt','a+')
print('没有躺赢的命，就请站起来奔跑！',file=wode)
wode.close()
#——————————————————————————————————————————————-第三章——————————————————————————————————————————————
present=input("大声想要社么礼物")
print(present)
a=input("请输入整数")
b=input("请输入第二个证书")
print(int(a)+int(b))
a=int(input("请输入一个整数"))
b=int(input("请输入一个整数"))
print(a+b)
print(type(1)) # 类 型
print(1+2) # 加 法
print(1*2) # 乘 法
print(1-2) # 减 法
print(1/2) # 除 法
print(11//2) # 整 除
print(11%2) # 取 余 数
print(2**4) # 求 平 方
print(9//-4) # 下 取 整
print(-9//4) # 下 取 整
print(-9%4) # 余数=被除数 - 除数*商 除数是负数，余数一定是负数。
a=b=c=20 #a、b、c、的对象里都存储了同一个地址。都指向 value为20的对象的地址。
#-------------------------------------------------《解包赋值》------------------------------------
a,b,c=20,30,40
print(a,b,c)
#-----------------------------------------------------------------《交换赋值》------------------------
a,b=14,23
a,b=b,a
print(a,b)
#--------------------------------------------------------------《比较运算》------------------------
# <、>、<=、>=、==、!= 两符号之间是“或 ||” 的关系。
a=10
b=10
print(a==b)
print(a is b)
list1=[11,22,33,44]
list2=[11,22,33,44]
print(list1==list2)
print(list1 is list2)
print(id(list1))
print(id(list2))
##一个变量有id、type、value， is比较id
#==比较value
# and 一假为假
# or 一真为真
# in 在**里面
s="djlksjd"
print("d" in s)
is是同一性运算符，“is”主要来判断两个对象的身份标识，及两者的基本要素“id”也叫统一性运算。
python 中整形对象和字符串对象是不可变对象，所以python会很高效的对他们进行缓存，所以在程序上来看，
本应该对他们进行创建新对象时，却并没有创建，而是对他们进行了缓存
但是python只缓存简单整形，因此python程序中，这些小整形会经常被用到，而python缓存的值也是有一定范围且可变的。
a = 2.0
b = 2.0
print(a is b)
a is b
------------------------------------------------《对象的布尔值为false》-------------------
python一切皆对象，所有的对象都有一个布尔值，
获取对象的布尔值 用函数 bool()
false
数值0
none
空字符串
空元组 () tuple()
空列表 [] list()
空集合 set()
空字典 {} dict()
-----------------------------------------------------《单分支》------------------------------
s=int(input("请输入一个整数" ))
if s%2==0:
print(s,"为偶数")
else:
print(s,"为奇数")
--------------------------------------------------------《多分枝》----------------------------------
score=int(input("请输入您的成绩 :"))
if 90<score<=100:
print("Aji")
elif 80<score<=90:
print("Bji")
elif 70< score<=80:
print("cji")
else:
print("大错特错")
num_a = int(input("请输入一个 整数"))
num_b = int(input("请输入一个 整数"))
if num_a >= num_b:
print(num_a,"大于",num_b)
else:
print(num_a,"小于",num_b)
———————————————————————————————————————----《条件表达式 》————————————---------------———————————————————————
num_a = int(input("请输入一个 整数"))
num_b = int(input("请输入一个 整数"))
# x if 条件语句 else y
# 结果为true if 条件语句 else 结果为 false
print(num_a,"大于",num_b) if num_a>=num_b else print(num_a,"小于",num_b)
#加号 在 print 里 是连接的意思，连接字符串，所以要把数字用str()变成字符串
----------------------------------------------《pass语句》------------------------------------------------
#用于搭建语法结构时占位。
-------------------------------------------《内置函数染个（）》-------------------------------------------------------
# range() 用以生成一个整数序列
1)range(stop) 创建一个[0,stop)之间的整数序列，步长为1
2)range(start,stop) 创建[start,stop)之间的整数序列，步长为1，
3)range(start,stop,step) 创建[start,stop)之间的整数序列，步长为step
#list（）#用于查看range（）对象中的整数序列， --》list是列表的意思
#不管range 对象表示的整数序列有多长，所有的对象占用的内存空间都是相同的，因为仅需要存储start，stop，step，只有用到range对象时，才会去计算序列中的相关元素
#用in 或者 not in 判断数值是否在数列中，
r=range(2,10,3)
print(list(r))
print(7 in r)
print(7 not in r)
----------------------------------------------《while循环》-----------------------------------------------
a =1
if a<10: #判断是否为ture是就执行，执行完就退出，
print(a)
a+=1
a =1
while a<10: #判断是否为ture是就执行，执行完 再判断是不是true，直到为false就退出，
print(a)
a+=1
#---------------------<0~4的总和用while>--------------------while 用于次数不固定的循环
a =0
sum=0
while a<5:
sum += a
a+=1
print("和为",sum)
#--------------------------------《1~100之间的偶数和》----------------------------
a=1
sum=0
while a<=100:
if not bool(a%2): # if a%2: 取奇数和 # if a%2==0: 取偶数
sum+=a
a+=1
print("和为",sum)
#------------------------------------《遍历for in》---------------- for 用于遍历字 符串 和 range()
for item in "python":
print(item)
#range()是一个可迭代对象(可用作循环次数)
for i in range(10):
print(range(i))
for _ in range(5):
print("python")
#----------------------------《一到一百内的偶数和》--------------------------
sum=0
for i in range(101):
if i%2==0:
sum += i
print("一到一百的偶数和：",sum)
#--------------------------------------《输出100到999之间的水仙花数》------------------------------------
#example: 三位数 = 个位数^3+十位数^3+ 百位数^3;
for item in range(100,1000):
a= item//100
b= item%100//10
c= item%10
if item==a**3+b**3+c**3:
print(item)
#-------------------------------------------《输入密码break》-----------------------------------------------------
#-------------------------------《for循环判断》-----------------------
for i in range(3):
pwd = str(input("请输入密码："))
if pwd=="888":
print("密码输入正确")
break
else:
print("密码输入错误")
#-----------------------------《while循环判断》---------------------
a=0
while a<3:
a+=1
pwd=input("qimm")
if pwd=="888":
print("you are right")
break
else:
print("wrong")
#-------------------------------------------《continue》------------------------------------------------
for i in range(1,51):
if i%5!=0:
continue
print(i)
i=1
while i<51:
if i%5!=0:
i += 1
continue
print(i)
i+=1
#--------------------------------------------《else》----------------------------------------------
#=============================================《for ~ ~ ~ ~ ~ ~ ~ ~else》==================
for i in range(3):
pwd = input("请输入您的密码：")
if pwd=="888":
print("对了")
break
else: for range()遍历 不需要 i++
print("错了重输")
else:
print("您已超出三次机会了")
#============================================《while ~ ~ ~ ~ ~else》========
a=0
while a<3:
pwd=input("请输入密码：")
if pwd=="888":
print("dui")
break
else:
print("错了")
a+=1
else:
print("辣鸡")
#------------------------------------《嵌套式循环》-----------------------------------------------
for i in range(3):
for j in range(4):
print("*",end="\t")
print()
#---------------------------------------《直角三角形》----------------------------------------------
for i in range(9):
for j in range(i+1):
print("*",end="\t")
print()
#----------------------------------------《9*9乘法表》-----------------------------------------------
for i in range(1,10):
for j in range(i+1):
if j==0:
continue
print(j,"*",i,"=",i*j,end="\t")
print()
for i in range(1,10):
for j in range(1,i+1):
print(j,"*",i,"=",j*i,end="\t")
print()
#----------------------------------------《break 和 continue》-----------------------------------------------------
#------------------------------------《流程控制语句break 、continue 在二重循环中的使用》---------------------------------
# break 退出当前循环圈儿 到上一层循环圈去继续循环
# continue 退出当前循环圈的本次循环， 下一次循环
# 都是对当前层循环进行操作。
for i in range(5):
for j in range(1,11):
if j%2==0:
#break
continue
print(j,end="\t")
print()
#-------------------------------------------《list》------------------------------------------------
#list=["hello","world",98] ================
# 列表元素须有序排序
#索引映射为一个数据 左——>右 0，1，2，3，4.... 右-——>左 -1,-2,-3,-4.......
#可以存储重复数据
#数据类型可以混存
#根据需要动态、分配和回收缓存，
lst=list(["hello","world",98,33,"python","ecnd","sd"])
print(lst)
print(lst.index(98)) #求列表中 元素98 的索引
print(lst.index("python",3,5)) # python 在小标为4的地方 在index标注的第3到第5中找python，包左不包右的
#先选中多行，然后按ctrl+/键注释，再按一次取消注释.
print(lst[4]) #lst[角标]
print(lst[-5])
#------------------------------------《获取列表中多个元素的-----切片操作》------------------------------------------
lst=[9,"sd",23,"sfg","sdfs","sdfc"]
print(lst.index(23,1,3)) #index(list中的value，从左数小标，从左数小标但不包含该位置）
print(lst[1:5:2]) #切片不包括下标为stop的值
lst2=lst[1:5:2]
print("原切:",id(lst))
print("切片:",id(lst2))
#新切的列表 id 和 源列表不一样
#切片是为了获取新列表 所以和列表原地址不一样
print(lst[1:6:])
print(lst[1:6])
#步长为1 省略步长
print(lst[:6:1])
#省略 start 从第一个开始
print(lst[1::1])
#省略 stop 列表长包含最后一个元素
print(lst[::-1])
#step 为-1 从start开始往前切片 #可以理解为倒叙
print(list[7::-1])
#从左数，下标为7的值开始，向 -1 方向切片
print(list[:4:-1])
#从-1方向开始，切到下标为stop的值（不包括stop）
#优先级：start > step > stop （切片不包括下标为stop的值）
print(list[:4:-2])
#一定不包括stop小标的value！！！！！！
#步长为2
--------------------------《列表元素的遍历和判断》-----------------------------------
#item 是迭代变量
#列表元素的遍历
list=[12,44,21,21]
for item in list:
print(item)
#列表元素的判断
print(12 in list)
print(32 not in list)
---------------------------------《列表元素 的 添加 操作》--------------------------------------
#append（添加一个元素） 在列表后面添加 一个 元素
#extend（列表名） 在列表后面添加 至少一个元素
#insert（a，b） 在列表a位置中 插入b元素
#添加不改变 list 的 id 地址（list存储的是列表的初始id）
list=[13,23,33]
print(id(list))
list.append(99)
print(list)
list1=['hole','ss']
list.extend(list1)
print(list)
list.insert(1,505)
list.insert(3,505)
print(list)
print(id(list))
#切片 =list 把新的列表赋值给切片
list=[13,23,33]
list.insert(0,505)
print(list)
list3=["wo","zai","zhe"]
list[1:2]=list3
print(list)
#---------------------------------《列表元素 的 删除操作》----------------------
#remove（元素） 一次删除一个元素
# 重复元素值 删除第一个
#元素不存在 valueError
list=[1,2,3,4,2]
print(id(list))
list.remove(2)
print(id(list))
print(list)
list.pop(2)
print(id(list))
print(list)
#pop(index) 删除一个指定索引位置上的元素
# 不指定索引会删除列表中的最后一个
#元素不存在 indexError
#切片删除 list[start:stop:step]=[](给一个空列表替代)
list=[1,2,3,4,2]
list.pop(2)
print(list)
list.pop()
print(list)
list[2:3:]=[]
#clear() 清空列表 空列表和源列表地址一样
list.clear()
#del() 删除列表
del list
------------------------------《列表元素 的更改》------------------------------
list=[1,2,3,4,5] #更改一个值 直接给索引赋值
list[3]=505
print(list)
list[2:3]=["I","LOVE","YOU"] #更改连着的一排值 直接给切片 赋 一个链表
print(list)
--------------------------------------《排序》-------------------------------------
list=[10,20,90,50,30,40]
list.sort()
print(list)
list.sort(reverse=True) # 倒叙
print(list)
list.sort(reverse=False) # 正序
print(list) #id不变 在原基础上改
========================《内置函数 sorted》=================
list=[10,20,90,50,30,40]
print(id(list))
print(list)
list=sorted(list)
print(id(list)) #内置函数 sorte（） 生成新的列表id
print(list)
list=sorted(list,reverse=True)
print(list)
list=sorted(list,reverse=False)
print(list)
-----------------------------《列表生成》-----------------------------------------------------------
list=[i*2 for i in range(1,6)]
print(list)
------------------------------------《字典》----------------------------------
str / int 是不可变序列
dict /list 是可变序列
dict()#内置函数
------------------------------------《新建字典》-------------------------------
score={"name":"张三","age":18,}
print(score)
score=dict(name="张三",age=18)
print(score)
score={}
print(score)
-------------------------------------《字典获取元素》--------------------------
score={"name":"张三","age":18,}
print(score["name"])
print(score.get("name"))
#print(score["陈丽"]) key Error
print(score.get("陈丽")) #none
print(score.get("陈丽",44)) #44
------------------------------------《字典元素 的 增 删 改》------------------------------------
score={"name":"张三","age":18,}
print("name" in score) #判断
score["sex"]="nv" #新增
print(score)
score["sex"]="nan" #更改
print(score)
del score["age"] #删除
print(score)
-===============================《获取字典视图》===============================
score={"name":"张三","age":18}
print(score)
keys=score.keys() #keys 属性 将所有的key组成的视图转成列表
print(keys)
values=score.values()
print(values) #将所有的value组成视图转成列表
items=score.items()
print(items) #dict_items([('name', '张三'), ('age', 18)])
# 属性 （）是元组的意思
#将所有的key-value对转成 元组的列表
=================================《字典元素的遍历》=====================================
scores={"name":"尹珺","gae":18}
for item in scores:
print(item,scores[item],scores.get(item,00))
=================================《字典的生成方式》======================================
#字典中的 key键不可重复 ， value值可以重复
d={"name":33,"name":88}
print(d) #key键重复 输出最后一个键
#字典元素是无序的
#字典的key必须是不可变对象
#字典是可以根据需要可动态伸缩的，
#字典会浪费较大的内存，是一种用空间换时间的数据存储方式
key=["name","li","sdm","werf"] #字典的创建
value=["sdjf","sg","sdfa","awe","s"]
dic={a.upper():b for a,b in zip(key,value)}
print(dic)
====================================《元组创建方式》======================================
a=(90,"name",88)
print(a)
print(type(a))
p="23name",23,"mme"
print(p)
print(type(p))
d=("name",) #单个元组 一定要有逗号
print(d)
print(type(d))
f= tuple((11,"name",98)) #tuple
print(f)
print(type(f))
================================《为什么要将元组设计不可变序列》================================
#为什么要将元组设计成不可变序列
#在多任务环境下 ，同时操作对象是不需要加锁
#因此程序中尽量使用不可变序列
#元组总存储是对象的引用：
#如果元组中对象本身不可变对象，则不能在应用其他对象
#如果元组中的对象是可变对象，则可变对象的引用不许改变，但数据可以改变
#字典字典由花括号定义 由键值对组成的一种结构 由哈希算法放入。。。。。
--------------------------------《元组 的 遍历》--------------------------------------------
t=("sd","sd",23,23)
for item in t:
print(item)
===================================《set（）集合》=====================================================‘’
#字典的定义：由{}定义 由 key:value 对所组成的 数据结构
#集合的定义：只有key 没有value值
s={'s','e','e','e','e'}
print(type(s))
#集合就是set()转化
#集合是无序的
#集合和字典是一样的 key重复 输出最后一个key
#转化字符串 要先分开字符串 在按照元素转化成 集合
# 总结 去重 打乱 转化
----------------------------------------《转化成集合》--------------------------------------------
jihe={"ds",34,"33"} #集合
print(jihe,type(jihe))
d=set(["se",3,33,53,53])
print(d,type(d)) #列表转化集合
s=set({"name":88,"set":99,"name":0})
print(s,type(s)) #字典转化集合
f=set((3,)) #元组转化集合
print(f,type(f))
zi=set("ee") #先分开 变成 "e" 和 "e" 然后 去重（字符串转化集合）
print(zi,type(zi))
a=set() #空转化集合
print(a,type(a))
s=set(range(5)) # 打乱顺序 转化集合
print(s,type(s))
y=set({"ee",33,"34"}) #转化集合
print(y,type(y))
# s={"name":88,"set":99,"name":0} #字典是去重的
# print(s.items()) #获取字典的以元组 为元素
# print(s.keys()) #获取字典的key
# print(s.values()) #获取字典的值
s={"name":88,"set":99,"name":0}
s["er"]=00
s["ersd"]=00
print(s) #字典添加是在末尾添加 重复的key 显示最后一个 放在第一个key的位置上
=========================================《集合的相关操作_____集合的新增操作》===================================
s.add("a") #添加一个元素a
s.update([32,345,32]) #添加至少一个list
s={33,24,5,543}
s.add("a") #添加一个元素
list={33,24,13}
s.update(list)
print(s)
s.update([32,345,32])
print(s) #添加至少一个list
s.update(("34","55"))
print(s) #添加至少一个元组
s.update("eee") #添加字符串
print(s)
---------------------------------------------《集合的相关操作》----------------------------------------------
s.add() #添加元素
s.update() # 添加至少一个元素
s={34,343,222,"df"}
s.add("sdsd")
print(s)
s.update(("sdf",343434,2223232)) #要转成集合 / list / 元组 等类型
print(s)
-----------------------------------《集合——删除》-----------------------
s.pop() #pop（）没有参数 不可添加参数
s.remove() #找不到删除元素 报异常
s.discard() #找不到删除元素 不报异常！！！
s.clear() #清除
s={44,"df",45,"er4","e4e4"}
print(s)
s.pop() #pop（）随即删除 一个元素 没有参数 不可添加参数
print(s)
s.discard(90) #有参数 但不报 error
print(s)
s.remove(88)
print(s) #报异常 error
s.clear() #清空
print(s)
=================================================《集合间的关系》====================================
A == B #判断 A B集合是否相等 （只要元素相等，不需要考虑地址）
A.issubset(B) #判断A是B的子集 对么
A.issuperset(B) #判断A是B的父集 对么
A.isdisjoint(B) #判断A 和 B 不相交 是无交集 是 true
s={1,2,3,4,5,6,7,8}
s4={4,2,1,3}
s1={1,2,3,4}
s2={2,3,9}
print(s2.isdisjoint(s))
print(s1.issubset(s))
print(s.issuperset(s2))
print(s1==s4)
print(s!=s4)
======================================《集合数据操作》===================================
#交集 差集 对称差集 并集
s={1,2,3,4}
s1={1,2,3,5}
print(s1.union(s)) #并集
print(s1|s)
print(s1.intersection(s)) #交集
print(s1&s)
print(s1.difference(s)) #差集
print(s1-s)
print(s1.symmetric_difference(s)) #差集
print(s1^s)
---------------------------------------《集合生成式》-------------------------------
s={i*i for i in range(10)} #和列表差不多
=================================================================================《字符串 的驻留机制》=====================
#字符串是不可变序列
-----------------------《驻留机制》-------------------------
1。字辅串长度为 1 或 0
2。符合标识符（字母 数字 下划线）
3。调用 类似 join（） 函数 前 是 驻留机制
4。[-5,256] 内的数字是 驻留机制
5。强制驻留： import sys
a=...
b=....
a=sys.intern(b)
#注意：pycharm 是强制 优化字符串 驻留机制
#join（） 这个函数 new 的效率高
----------------------------------------------《字符串的查询》------------------------------------------
# .index("字符串") 左侧开始查询
# .rindex("字符串") 右侧开始查询
没有会报error
# .find("字符串") 左侧查询
# 。rfind("右侧查询") 右侧查询
没找到 就 报 -1
-------------------------------------------------《字符串的大小写转换》------------------------------------------
# .title() 每个单词的抬头 大写
# .swapcase() 原单词的大小写转换
# .upper() 全大写
# .lower() 全小写
# .capitalize() 仅第一个首字母大写
------------------------------------------------------《字符串内容对齐的操作》---------------------------------------------
# .center(20,*) 居中对齐 宽度小 则反原字符
# .ljust(20，*) 左对齐 （字符串的宽度 ，用*号填充）
.ljust(20) 宽度小 返回原字符 宽度大 没有填充参数 用空格填充
# .rjust(20,*) 右对齐 其余同上
# .zfill(20) 右对齐 宽度大 用 0 填充 多余空格 宽度小 返回 原字符
s=“-42f”
print(s.zfill(8)) -00042f
---------------------------------------------------------《字符串的劈分》------------------------------------------------
# .split() 默认空格 分串
# .split(sep="|") 以 这个 | 为基准 把字符串分 段 不包含这个 “|”
# .split(sep="o",maxsplit=2） 以这个字符串 “o” 为基准分段 不包含 “o” 从左数 最大分 2次（3段）
.rsplit() #同上相反的
s="hello world | i love you"
print(s.split())
print(s.split(sep="o",maxsplit=2))
=====================================================《字符串的判断》=================================================
.isidentifier() 判断是否符合 合法标识符
.isdecimal() 判断是否符合十进制数（包含数字0)
.isalpha() 是否符由字母组成
.isnumeric() 符合 数字么 ”四“ ”罗马数字“ ”656“ 都算数字
.isalnum() 判断 是否 由 数字和字母 组成
.isspace() 空字符串 （回车空格水平制表符）
==================================================《字符串的替换链接》====================================
#.replace(原，新，换几次)
# "**".join(t) 把t列表 里的字符串 用**链接起来
# “**”.join("python") 结果： p**y**t**h**o**n
t="hello,hello,G,hello"
print(t.replace("hello","A",3))
t=["hello","nin","hello","hello"]
print(type("".join(t)))
print("*".join("python"))
================================================《字符串的比较》=================================================
ord("单个字符")
chr("单个字符")
print("abc"<"abcd")
print(ord("a"),chr(97))
====================================================<字符串的切片>====================================================
s="hello,world"
print(s[3:8:]) #包首不包尾，生成新id
print(s[-2:-8:-1]) #倒叙
===================================================《字符串的格式化》============================================
# print("{0:*^20.3f}".format(3.14155926))
# print("%10d"%(5))
# print(f"{44:*^10.2f}")
# print(f"{33.222:*^10.7}")
#笔记注释
=======================================================《字符串的编码与解码》==================================
#编码格式： ”GBK“（一个中文占两个字节） "UTF-8"（三个）
s="天元区多"
print(s.encode(encoding="GBK"))
e=s.encode(encoding="GBK")
print(e.decode(encoding="GBK"))
s="天元"
print(s.encode(encoding="UTF-8"))
e=s.encode(encoding="UTF-8")
print(e.decode(encoding="UTF-8"))
=====================================================《函数的定义》============================================
=======================================================《函数传递》======================================
#实参 传递
#关键字传递
========================================================《全局变量》=========================================
def fun():
global age #用global 后 age 变全局变量
print(age)
========================================================《递归》=========================================
定义：调用函数本身为递归
组成：递归调用 + 结束语
过程：每调用一次 都在站内分配一个栈帧
每执行完一次 都释放一次相应的空间
优点：思路代码清晰 简单
缺点：占用内存多 效率低
def fib(n):
if n==1:
return 1
else:
return n*fib(n-1)
print(fib(6))
=======================================================《斐波那契数列》===============================
def fib(n):
if n==1:
return 1
elif n==2:
return 1
else:
return fib(n-1)+fib(n-2)
for i in range(1,7):
print(fib(i))
=======================================================《斐波那契数列 列表》===============================
list=[]
def a(m):
for n in range(1,m+1):
def fun(n):
if n == 1:
return 1
elif n == 2:
return 1
else:
return fun(n - 1) + fun(n - 2)
list.append(fun(n))
print(list)
print(type(a(6)))
==================================================================《》================================================
for i in range(3):
uname=str(input("输入用户名"))
pwd=int(input("请输入密码"))
if uname=="admin" and pwd==998:
print("正确")
break
else:
print("重新输入")
else:
print("三次都错了")
================================================================================import traceback========
try:
print("-------------------------")
print(1/0)
except:
traceback.print_exc()
-------------------------------------------《递归》-------------------------------------------------------
def fac(i):
if i==1:
return 1
else:
return fac(i-1)*i
run=fac(6)
print(run)
list=[]
def a(m):
for n in range(1,m+1):
def fun(n):
if n == 1:
return 1
elif n == 2:
return 1
else:
return fun(n - 1) + fun(n - 2)
list.append(fun(n))
print(list)
print(type(a(6)))
class Person(object):
def __init__(self,name,age):
self.name=name
self.age=age
def info(self):
print("姓名：",self.name,"年龄：",self.age)
class Student(Person):
def __init__(self,name,age,stu_NO):
super().__init__(name,age)
self.stu_NO=stu_NO
def info(self):
super().info()
print("学号：",self.stu_NO)
stu=Student("张三",12,'1101')
import os
path=os.getcwd() --------------------输出当前路径
print(path)
list=os.listdir(path) --------------------当前路径下的文件列表
print(list)
for filename in list: --------------------输出路径里的py文件
if filename.endswith(".py"):
print(filename)
a=0 --------------------输出100以内的奇数
sum=0
while a<101:
if bool(a%2):
sum+=a
a+=1
print(sum)
sum=0 -------------------输出100以内的奇数
for i in range(101):
if i%2:
sum+=i
print(sum)
a=0 ---------------------输出 ”个为的立方“ 加 ”十位的立方“ 加 ”百位的立方“ 等于 这个数
b=0
c=0
for i in range(100,1000):
a=i%10 #个位数
b=i//10%10 #十位数
c=i//100 #百位数
if i==a*a*a+b*b*b+c*c*c:
print(i)
for i in range(3): -------------------- 用for in 循环 判断密码是否正确
pwd=input("请输入密码:")
if pwd=="888":
print("密码正确")
break
else:
print("密码错误，请重新输入：")
a=0 ------------------- 用while循环 判断密码是否正确
while a<3:
pwd=input("请输入密码：")
if pwd=="888":
print("密码正确！")
break
else:
print("密码错误")
a+=1
for i in range(1,51): ---------------------- 输出1-51之间，不是5的倍数
if i%5==0:
continue
print(i)
for i in range(3): --------------------- 遍历3次不成功输出 “已经输出3次”
pwd=input("请输入密码：")
if pwd=="888":
print("密码正确！")
break
else:
print("密码错误，请重新输入")
else:
print("已经输入三次")
a=0 ----------------------- while 循环密码程序
while a<3:
pwd=input("请输入密码：")
if pwd=="888":
print("密码输入成功！")
break
else:
print("密码输入失败！")
a+=1
else:
print("你已经输入3次")
for i in range(1,10): ------------------------- 用for遍历 打印阶梯阵星星
for j in range(1,i+1):
print("*",end="\t")
print()
for i in range(1,10): ----------------------------- 用for in套for in 写乘法表
for j in range(1,i+1):
a=i*j
print(j,"*",i,"=",i*j,end="\t")
print()
class Person(object): #-------------------《继承》《封装》----------
def __init__(self,name,age):
self.name=name
self.__age=age #------------------《隐藏属性》---------------
def info(self):
print("姓名：",self.name,"年龄：",self.__age)
class Student(Person):
def __init__(self,name,age,stu_NO):
super().__init__(name,age)
self.stu_NO=stu_NO
def info(self): #--------------------《方法重写》-----------------
super().info()
print("学号：",self.stu_NO)
stu=Student("张三",12,'1101')
def show(): #----------------《动态绑定方法》-----------------
print("聂峰")
stu.show=show
stu.info()
stu.show()
# print(stu.__age)
# print(dir(stu))
print(stu._Person__age)
class Student(): #-----------------str重写，返回对象的描述
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):
return "{0},{1}".format(self.name,self.age)
stu=Student("张三",10)
print(stu)
class Animal(object): -------------------《多态》-------
def eat(self):
print("动物吃肉")
class Dog(Animal):
def eat(self):
print("狗吃肉")
class Cat(Animal):
def eat(self):
print("猫吃鱼")
class Person(object):
def eat(self):
print("人吃人")
def fun(obj):
obj.eat()
fun(Animal())
fun(Dog())
fun(Cat())
fun(Person())
class A(): #-------------------------《特殊属性》----
pass
class B(A):
pass
class D():
pass
class C(B,D):
pass
x=C()
print(A.__subclasses__())
print(x.__class__)
print(C.__dict__)
print(x.__dict__)
print(C.__mro__)
print(C.__base__)
print(C.__bases__)
class Student(): #-------------------《特殊方法》
def __init__(self,name):
self.name=name
def __add__(self, other):
return self.name+other.name
def __len__(self):
return len(self.name)
s1=Student("A")
s2=Student("B")
s=s1+s2
print(s)
s=s1.__add__(s1)
print(s)
x=len(s1)
print(x)
x=s1.__len__()
print(x)
class Person(object): #----------------- __new__方法和 __init__ 方法
def __new__(cls, *args, **kwargs):
print("new的id为{0}".format(id(cls)))
obj=super().__new__(cls)
print("obj的认为{0}".format(id(obj)))
return obj
def __init__(self,name,age):
print("self的Id为{0}".format(id(self)))
self.name=name
self.age=age
print("object类id为{0}".format(id(object)))
print("Person的id为{0}".format(id(Person)))
p=Person("张",20)
print("p的id为：",id(p))
#----------------copy浅拷贝
#----------------deepcopy深拷贝
answer=input("您是会员么：y/n") #------------会员金额
money=float(input("请输入付款金额"))
if answer=='y':
if money>=200:
print("付款金额：",money*0.8)
elif money>=100:
print("付款金额：",money*0.9)
elif money>=50:
print("付款金额：",money*0.95)
else:
if money>=200:
print("付款金额：",money*0.95)
else:
print("您的付款金额：",money)
is是内存地址的比较
==是value的比较
对象由三部分组成 id type value
python一切皆对象 所有对象都有一个布尔值bool（）
a=int(input("输入一个")) #--------比较大小
b=int(input("输入一个b"))
print( str(a)+"大于等于"+str(b) if a>=b else str(a)+"小于等于"+str(b))
lst=[1,2,3,4] #--------和insert差不多
lst2=["hello","python"]
lst[2:3]=lst2
print(lst)
lst.insert(3,99) #---------在index为3的位置插入，原有的下标3往后挪动
print(lst)
print(lst.index("hello")) #-------------输出元素的下标
print(lst.index(99,2,5))
lst6=[1,2,3,4,5,6]
lst6.remove(2) #--------remove里要填写元素不可填写index
print(lst6)
lst6.pop()
print(lst6)
lst6.pop(1)
print(lst6)
print(lst6.index(1))
lst7=[10,20,30,40] #---------------------切片list
lst7[1:3]
print(lst7[1:3])
lst=[100,2800,300] #--------排序列表lst.sort(reverse--) sorted(lst,reverse--)
print(id(lst))
lst.sort()
print(lst)
lst.sort(reverse=True)
print(id(lst))
print(lst)
print("--------------------------")
newlst=sorted(lst,reverse=False)
print(newlst)
lst=[i*i for i in range(1,10)] #-----------列表生成式
score={"张三":100,"里斯":90,"阿里":20} #---------字典的创建
print(score)
SS=dict(name="张三",age=20)
print(SS)
d={}
print(d)
score={"张三":32,"里斯":344}
print(score["张三"])
print(score.get("马蹄",41)) #-------------若不存在则报41
score={"里斯":22,"案例":34,"饿哦":32} #------------------增删改查
score["A"]=00
del score["饿哦"]
score["里斯"]=999
print("案例" in score)
print(score)
score={"爱我":00,"牛逼":57,"家具":33} #-------------------获取字典视图
keys=score.keys()
print(keys)
print(type(keys))
print(list(keys))
values=score.values()
print(values)
print(type(values))
print(list(values))
items=score.items()
print(items)
print(type(items))
print(list(items))
score={"LA":100,"KD":15} #---------获取字典的值
for item in score:
print(item,score[item],score.get(item))
item=["lda","dd","sde"] #----------------字典生成式
value=[55,28,66,47]
d={item.upper():value for item,value in zip(item,value)}
print(d)
s='hello pleelwtg' #-----------劈分
lst=s.split()
print(lst,id(s),id(lst))
print(s.split('l',maxsplit=1),id(s))
s='hellopyhton'
print(s.isidentifier())
print(s.isalnum())
print(s.isnumeric()) #是否是数字组成（一二三四/1234/罗马数组一二三四）
print(s.isalpha()) #是否由 张三或者abc 组成
print(s.isspace())
print(s.isdecimal())
name='Haha'
age=11
print('我叫%s,今年%d岁'%(name,age)) #----占位符
print('{0}{1}'.format(name,age)) #---占位符
print('%.f' % 3.1415926) #-----点f表示 一个宽度
print('%f' % 4.562960155) #------f表示小数
print('{0:.3}'.format(3.1415)) #-------点3表示宽度为3个的小数
print('{0:10.3}'.format(3.1415926)) #--------数字取3个长度，总宽度用10个位置
item="aa Ad fG" #---------修改字符串的大小写
print(item.upper())
def fun(*arg,**B): #-----------（个数可变的位置形参）和（个数可变的关键字形参）
print(arg)
print(B)
fun(10,22,42)
fun(name='离散',age=10)
lst=[12,33,441,2]
dict={"name":"离散","age":23}
fun(*lst)
fun(**dict)
print("------------------------")
fun(10,20,30,a=10,b=100)
def fun(a,b,c,d): #-----------------调用函数
print(a,b,c,d)
fun(10,20,c=10,d=40)
def fun(n): #递归函数阶乘
if n==1:
return 1
else:
return n*fun(n-1)
print(fun(6))
def fac(a): #----------斐波那契数列
for i in range(1,a):
def fun(i):
if i==1:
return 1
elif i==2:
return 1
else:
return fun(i - 1) + fun(i - 2)
print(fun(i),end=" , ")
fac(7)
file=open('a.txt','r',encoding='utf-8') #----------window默认是GBK，utf-8会报错，两种解决办法：1.文件改成gbk，2，系统格式改成utf-8
print(file.readlines())
file.close()
file=open('c.txt','a') #写在新文件里
file.write('后')
file.close()
A=open('.png','rb') #二进制文件的复制 rb 或者 wb “a+”读写模式
B=open('copy.png','wb')
B.write(A.read())
A.close()
B.close()
file=open('a.txt','w') #----------文件的 writelines（）
lis='hello'
file.write(lis)
file.write('\n')
file.write(lis)
file.close()
file=open('a.txt','r')
print(file.read())
file.close()
file=open('a.txt','w')
lst=['朱一品\n','吼吼']
file.writelines(lst)
file.close()
file=open('a.txt','r')
file.seek(1) #------汉字是seek（2）2个字节，英文是seek（1）1个字节,seek()从数字1开始，没有下标是0的说法
print(file.read())
file.close()
"""
file=open('a.txt','r')
file.seek(3)
print(file.read())
file.close()
2854
04-21
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
