import keyword # 引入模块
from builtins import str, list
from _ast import List
print('你好, python')
#单行注释 学习笔记
'''
多行注释
`变量命名规则:
变量名可以包含数字,大小写字母,下划线或者更多
不可以已数字开头
一般在Python中,以下划线开头的内容有具体含义,不建议使用
大小写敏感
`推荐用法
使用具有固定含义的英文单词或者缩写
大驼峰--类命名
小驼峰--函数或者普通变量命名
posix写法--多个单此用下划线连接,单词全部小写
除保留,字关键字
'''
print('系统关键字，保留字')
for imet in keyword.kwlist:
print(imet)
#变量声明--三种方式
name='1'
print(name)
name=name1=name2='2'
print(name1)
name,name1,name2,name3='1','2','3','4'
print(name3)
#数据类型
'''
Python中用父类Object，不用指定数据类型，特殊转换除外
`细分数据类型
#Number(数字)
#Str(字符串)
#List(列表)
#Tuple(元组)
#Sets(集合)
#Dict(字典)
'''
'''
##数字类型
#整数
数字没有大小限制
自然数，负自然数，0
可以用进制表示
'''
sum=9999999999999999999999999990000999999999999999999999999999
print(sum)
'''·
##浮点
小数
可以有条件省略
可以科学记数法E
'''
sum=.5e2
print(sum)
'''
##布尔
Python中没实际的True,False
布尔可以直接跟数字0，1操作
1--True,0--False
'''
print(1==False)
'''
##字符串类型
用来表示字符串
-单引号
-双引号
-三引号(一对三单引号或者一对三双引号)
单双引号交错使用
'''
print('我叫',end='')
print("刘端武",end='')
print('''
我在自学Python
''')#***三引号可以多行
'''
##字符串
转义字符串--用特殊方法表示不方便写出来的内容--比如回车，换行 ###借助反斜杠\
'''
print('我要用\\n\n换行')
####使用r去除转义
print(r'不要换行了\n不管你信不信')
'''
##字符串格式化
利用百分号（%）
利用format函数
'''
s='大家好我叫%s'
#特别注意的点，前面要有一个变量
print(s%'刘端武')
###推荐使用format函数
s='大家好!我叫{0},今年{1}岁,大家可以叫我{0}'.format("刘端武", 20)
print(s)
'''
##None值
表示什么都没有
如果函数没有返回值可以返回None
用来占位置
用来解除变量绑定
'''
'''
·##表达式
由一个或者几个数字或者变量和运算符组合成的一行代码
通常会返回一个结果
'''
'''
##运算符
由一个以上的值经过变化得到的新值的过程就叫运算
用于运算的符号叫运算符
##运算符分类
算数运算符 ---加减乘除(+,-,*,/)以及取余% ##特别注意Python没有自加自减运算符
比较或关系运算符 --两个值或在变量进行比较用(==/!=/</>/>=/=<)返回True/False
逻辑运算符 --对布尔值进行计算的符号 (and/or/not)Python中逻辑运算没有异或运算
赋值运算符 --用于赋值（=/+=/-=//=/%=/**=）
成员运算符--用于检测某一个变量是否是另一个变量的成员（in/notin）
身份运算符--用来检测两个变量是否指向同一块内存（is/isnot）
'''
'''
##三大结构
顺序
分支
循环
'''
'''
##分支结构
基础语法1--
if 条件;
语句1
语句2
语句3
.........
表达式就是计算结果必须为布尔值的表达式
表达式后面不能少
注意if后面的出现的语句，如果属于if语句块，则必须同一个缩进等级
条件表达式结果为True执行后面的缩进的语句块
##双向分支结构
if.....else...
双向分支有两个分支，当程序执行到if....else....语句的时候，一定会执行if或else中的一个，也仅执行一个
##多路分支结构
很多分支的情况，简称多路分支
if 条件表达式：
语句1
。。。
elif 条件表达式：
语句2
。。。
else：
语句3
.。。。
elif可以有很多个
else可选
多路分支只会选一个执行
'''
name='刘端午'
if name=='刘端武':
print('是刘端武没错')
else:
print('他不是刘端武他是',name)
'''
##input的作用
在屏幕上输出括号里的字符串
接收用户输入的内容并返回到程序
input返回的内容一定是字符串类型
'''
#name=input('输入你要的值')
'''
##循环语句
重复执行某些固定动作或在处理基本固定的事物
for循环
for 变量 in 序列：
语句1
语句2
........
for-else 语句
当for循环结束的时候会执行else语句
else语句是可选语句
##while循环
一个循环语句
表所当某条件成立的时候就可以循环
不知道具体循环次数，但能确定循环的成立条件的时候用while
while语法--
while 条件表达式：
语句块
while....else...
while....else...语法
while 条件表达式：
语句1
else
语句2
##·循环之break，contineu,pass
break--无条件结束整个循环，简称循环猝死
contineu --无条件结束本次循环，重新进入下一轮循环
pass--表示略过
'''
name=['刘端午','刘端武','刘端','刘武']
for item in name:
print(item)
if item=='刘端武':
pass#占为符
print('他是刘端武')
break
else:
print('他不是刘端武')
else:
print('其他人都不是了，别来打扰了')
'''
range函数介绍
生成一个数字序列
具体范围可以控制
'''
for itme in range(1,11):
print(itme)
benqian=10000
year=0
while benqian<2000:
benqian=benqian*(1+0.067)
year+=1
print("第{0}年拿了{1}块钱".format(year,benqian))
else:
print('没钱拿了')
'''
##函数
代码的一种组织形式
一个函数一般完成一项特殊的功能
#函数的使用
函数需要先定义
'''
'''
##定义一个函数
定义函数不会被执行
def关键字后跟一个空格 跟函数名
函数名自己定义，遵循小驼峰命名规则
后面括号和冒号不能省略
函数内所有代码缩进
'''
def main():
print('这是一个函数')
'''
#函数的调用
直接返回函数名后面跟括号
'''
main()
'''
##函数的参数和返回值
#参数：负责给函数传递一些必要的数据或者信息
形参：在函数定义的时候用到的参数，没有具体值，只是一个占为符
实参：在调用函数的时候输入的值
#返回值：函数的执行结果
使用return关键字返回结果
如果没有return默认返回None
函数一旦执行return语句，则无条件返回，函数结束
'''
def printMain(name):
print('我是传入的值',name)
return '我是返回值'
print(printMain('刘端武'))
'''
练习，循环打印
*
***
*****
*******
*********
要求每次输出加三，可以选择输入行数
'''
def cousp():
#定义要多少行的参数
count=int(input('请您输入要印的三角形行数'))
#定义空格数
sp=count
for _ in range(1,count+1):
#打印空格数递减
for rowsp in range(1,sp+1):
print(' ',end='')
sp-=1
#打印*号4-1的形式
for val in range(0,(_*2)-1):
print('*',end='')
print('')
##函数查询
#help(print)
'''
##参数详解
#参数分类
普通参数
默认参数
关键字参数
收集参数
#普通参数
定义的时候直接定义变量名
调用的时候直接把变量或值放入指定位置
定义
def 函数名 （参数1，参数2）
函数体
#调用
函数名（values1，values2）
调用的时候，具体参考的是位置，按位置赋值
#默认参数
形参带有默认值
调用的时候，如果没有对相应形参赋值则使用默认值
定义
def 函数名（参数1=value1，参数2=value2）：
函数体
#调用方式1
函数名（）
调用方式2
函数名（value1，value2）
#关键字参数
不容易混淆，一般实参和形参只是按照位置一一对应容易出错
使用关键字参数，可以不考虑参数位置
定义
def 函数名（参数1=val1，参数2=val2.....）：
函数体
调用
函数名（参数1=val1，参数2=val2......）
#收集参数
把没有位置，不能和定义时的参数位置相对应的参数，放入一个特定的数据结中
收集参数可以不带任何参数，此时收集参数为空
定义
def 函数名（*参数）：
函数体
按照list使用方式访问参数得到传入的参数
调用
函数名（参数1，参数2，参数3........参赛n）；
#收集参数之关键值
把关键字参数按字典格式存入收集参数
定义
def 函数名（**参数）：
函数体
调用
函数名（参数1=val1，参数2=val2.....）
访问时直接按字典格式访问
#收集参数混合调用的顺序问题
收集参数，关键字参数，普通参数可以混合使用
使用规则就算，普通参数和关键字参数优先
定义的时候一般找普通参数，关键字参数，收集参数
'''
def helpValue(val='print',name='刘端武'):
##函数查询
print('{0}在调用函数查询，查询{1}函数'.format(name, val))
help(val)
return
print(helpValue())
print(helpValue('open',name='刘端武啊啊啊'))
#收集函数
def sut(*ked):
print(type(ked))
for item in ked:
print(item)
return
sut()
sut(1,2,3,4,5,6)
def sut1(**kwargs):
'''
这是文档
'''
print(type(kwargs))
if(kwargs.__len__()>0):
print("参数1{0}，参数2{1}，参数3{2}".format(kwargs["val1"],kwargs["val2"],kwargs["val3"]))
else:
print("无传入参数")
return
sut1(val1="a",val2="b",val3="c")
sut1()
'''
##函数文档
函数的文档的作用是对当前函数提供相关的参考信息
#文档的写法
在函数的内部开始的第一行使用三字字符串定义符
一般具有特定格式
#文档查看
使用help函数
使用__doc__
'''
help(sut1)
print(sut1.__doc__)
'''
##变量作用域
变量由作用范围限制
#分类
全局:在函数外部定义
局部：在函数内部定义
#变量的作用范围
全局变量：在整个类范围都有效，在局部可以使用
局部变量：在局部范围可以使用，在局部外无法使用
LEGB原则
L（local）局部作用域
E（Enclosing function tocale）外部嵌套函数作用域
G（global module）函数定义所在模块作用域
B（bulidin）Python内置作用域
##提升局部变量为全局变量
使用关键字：global 变量名
#使用globals,locals函数
提示出全局变量和局部变量
#evan()函数
把一个字符串当成一个表达式执行，返回表达式执行后的结果
语法
eval(string code,globals=None,locals=None)
#exec()函数
跟evan（)功能相似，但是不返回结果
语法
exec(string code,globals=None,locals=None)
'''
x=100
y=100
zz=x+y
z=eval("x+y")
zzz=exec("x+y")
print(zz)
print(z)
print(zzz)
'''
##递归函数
函数直接或者简介调用自身
优点：简介，理解容易
缺点：对递归的深度有限制，消耗资源大
Python对递归深度有限制，超过限制报错
写递归一定要写结束条件
'''
digui=0
def function():
#标记为调用全局变量
global digui
digui += 1
print(digui)
if digui==997:
return
function()
function()
'''
递归示例
斐波那契数列
一列数字，第一个值是1，第二个也是1，从第三个开始，每个数字的值等于前两个数字出现的值的和
数字公式：f{1}=1,f{2}=1,f{n}={fn-1}+f{n-2}
例如：1,1,2,3,5,8,13.........
'''
#n表示第n个数字的斐波那契数列的值
def fib(n):
if n==1:
return 1
if n==2:
return 2
if n<=0:
return
return fib(n-1)+fib(n-2)
print(fib(1))
'''
##内置数据结构
#list
#set
#dict
#tuple
#list(列表)
一组由顺序的数据组合
#列表常用操作
`访问
使用下标(索引)操作----索引从0开始
`分片（切片）操作
对列表进行任意一段进行截取
[:]
下标值可以为空，如果不写左边默认为0，右边下标为最大未知数+1，即表示最后一个数据
切片可以修改增长幅度，默认长度为1
[::n]
下标可以超出范围，超出后不在考虑多余的下标内容
下标可以为负数，为负数表示从由往左
规定数字最后的下标是负一
默认从左往右
正常情况下右边的值小于右边
'''
l=[1,2,3,4,5,6,7,8,9,10]
type(l)
print(l[0:4])
print(l[0:10:2])
print(l[-7:-1])
print(l[-1:-7:-1])
'''
#id()函数
显示一个变量或者数据的唯一确定编号
'''
print(id(l))
print(id(l[:]))
'''
#汉诺塔
规则
每次移动一个盘子
任何时候大盘子在下面，小盘子在上面
'''
def hanoi(n,a,b,c):
if n==1:
print(a,"-->",c)
return
hanoi(n-1,a,b,c)
print(a,"-->",c)
hanoi(n-1, a, b, c)
hanoi(5,"a","b","c")
'''
del 删除
del 一个变量后不能在继续使用此变量
'''
a=0
del a
##列表操作
#使用加号连接两个列表
a=[1,2,3,4,5]
b=[6,7,8,9]
c=['a','b','c']
d=a+b+c
print(d)
#使用乘号操作列表
#列表直接和一个整数相乘
#相当于把n个列表连在一起
a=['a','b','c','d']
b=a*3
print(b)
#成员资格运算
#就是判断一个元素是否在list里面
a=['a','b','c','d']
b='a'
#返回一个布尔值
c=b in a
print(c)
#while访问list
list=['a','b','c','d']
index=0
while index<list.__len__():
list[index]
print(list[index])
index+=1
#双层列表循环
###k,v的个数应该跟解包出来的变量一致
a=[[1,2],[2,3],[4,5]]
for k,v in a:
print(k,"-------",v)
'''
##列表内涵： list content
通过简单方法创作列表
'''
#对a*10，生成一个新的List
a=[1,2,3,4,5]
b=[i*10 for i in a]
print(b)
#过虑原来List中的内容放入新的列表
a=[x for x in range(1,21)]
b=[m for m in a if m%2==0]
print(b)
##嵌套列表生成 #嵌套也可以使用if判断
a=[x for x in range(1,11)]
print(a)
b=[j for j in range(1,100) if j%2==0]
print(b)
c=[m+n for m in a for n in b]
print(c)
'''
##列表的常用函数
#len()获取列表长度
#max()获取列表中最大值
#min()获取列表最小值
#list()转换成list类型
#append()在列表最后追加数据
#insert(indedx，val) 将值插入指定位置
#del list 删除指定列表
# pop（） 从对位拿出一个元素，即把最后一个元素取出来
#renove（val） 删除指定值 如果list中没有指定值即报错
#clear() 清空列表
#reveres() 翻转，原地翻转
#extend(list) 扩展列表，把一个直接拼接到后一个上
#count() 查找指定值的元素个数
#copy() 拷贝，只拷贝一层 浅拷贝 防止值传递
'''
list=[x for x in range(1,11)]
print(len(list))
print(max(list))
print(min(list))
list.append(44)
print(list)
list.insert(0, 20)
print(list)
#del list
#print(list)
list.pop()
print(list)
list.pop(0)
print(list)
list.remove(4)
print(list)
#list.clear()
#print(list)
list.reverse()
print(list)
listb=[x for x in range(1,10)]
list.extend(listb)
print(list)
print(list.count(2))
list=listb.copy()
print(list)
'''
##元组-tuple
#元组可以看成一个不可变更的list 只指内容不能修改
#元组的创建
t=(1,)
##元组的特性
#是有序列表
#元组值可以访问，不能修改，删除，插入
#元组数据可以是任何类型
#元组由list所有特性 除了不能修改外
#list具有的一些操作，比如索引，分片，序列相加，相乘，成员资格操作等，一模一样
'''
#创建一个只有一个值的元组
t=(1,)
print(t)
print(type(t))
li=[1,2,3,4,5,6]
t=tuple(li)
print(type(t))
print(t)
#元组遍历
for i in t:
print(i)
'''
##集合-set
一堆确定的无序的唯一的数据，集合中每一个数据成为一个元素
#集合的特点
集合内数据无序，即无法使用索引和分片
集合内部数据元素具有唯一性，可以用来排除重复数据
集合内的数据，str，int，float，list。即内部只能放置哈希数据
'''
##操作集合
s = {1,2,'33','aa','bb','a',1,1,2,2}
print(s)
for x in s:
print(x)
'''
##集合的函数
集合自动去除重复元素
len,max,min基本与list一致
set生成一个集合
add添加元素
clera清空
copy拷贝
reomve删除
discard移除集合中指定的值，没有不报错
pop随机移除一个值
intresection:交集
difference:差集
union：并集
issubset：检查一个集合是否为另一个子集
issuperset:检查一个集合是否为另一个集合的超集
'''
'''
frozen set ：冰冻集合
冰冻集合是不可以进行修改的集合
frozen set 是一种特殊集合
'''
'''
##dict字典
字典是一种组合数据，没有顺序的组合数据，数据以健值对形似出现
字典是序列类型，但是是无序序列，所以没有分片和索引
字典中的数据每个都是kv对
key必须是可哈希的值
val可以是任何值
创建有值的字典，每组数据用冒号隔开，每一对犍值对用逗号隔开
创建方式：直接创建一个有值的数据，用dict（）创建，用元组创建
'''
