• 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()创建,用元组创建
    
    '''
  • 相关阅读:
    公约数
    [TJOI2017]异或和
    [HNOI2014]世界树
    小清新数据结构题
    CF809E 【Surprise me!】
    [JXOI2017]颜色
    docker swarm集群
    jenkins构建maven项目
    jenkins软件工具部署
    jenkins持续集成
  • 原文地址:https://www.cnblogs.com/liuduanwu/p/9520602.html
Copyright © 2020-2023  润新知