Python笔记

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
换行')
####使用r去除转义
print(r'不要换行了
不管你信不信')

'''
##字符串格式化
利用百分号(%)
利用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()创建,用元组创建

'''
原文地址:https://www.cnblogs.com/liuduanwu/p/9520602.html