python 学习笔记1

#集成工具 pycharm 的汉化包下载与使用    

　　 https://github.com/linzhenyuyuchen/Others/

        将resources_cn.jar放到pycharm 安装目录下的lib目录下即可

        

        汉化后可能导致的问题：文件file—>设置setting， 无法打开

        将resources_cn.jar移除之后可恢复

　　 汉化问题多，我还是用原版英文的算了，多用用就熟练了 　　`...`        

    

#命令行部分

　　dir　　　　　　　　　　浏览目录

　　mkdir make dir　　 　　   创建文件夹

　　rmdir remove dir 　　　　删除目录

　　ipconfig 　　　　　　　　查看ip地址

　　ping 　　　　　　　　测试网络连接

　　pip freeze > requirements.txt 　　　　　　　　将项目依赖的包输出到指定的文件

　　pip install -r requirements.txt 　　　　　　　　读取文件并下载

 

#代码部分

　　#输入，打印

       　　 input('请输入：' ) 　　输入流

　　　　 print(r'')　　　　　　  打印

　　#原样输出 不转义

　　　　print(r'') 　　　　　  #  r 原样输出

　　　  ‘’‘　　　　　　　　#  三引号‘’‘　　1、原样输出　　2、多行注释的开始和结尾

 　　#占位符

　　　　print('xxxx%sxxx%sxxxx%d' %(val1,val2,val3))　　　　

　　　　　　#   %s  占位符 str  字符串。变量 val1,val2,val3 分别依次对应3个占位符

 　　　　　　#　%d   占位符 digit 整型数字　　　　　　　　　　　　　　　　　　　  　

　　　　print('我的薪水是：%.1f' %(val)) 　　　　　　　　　

　　　　　　#　%.1f   占位符    指定小数点后面的位数1　　%.2f  小数点后2位

　　　　#‘’ {} ‘’.format(  )   代替 %s等繁琐的写法

 　　　　age = 2 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

　　　　person = 'sisite' 

　　　　message = 'i say :i am {}year`s old.such as my {}'.format(age,person) 

　　　　print(message) 

        #位运算符

            & 与 　　二进制解释，相同位，均为1得1，否则得0

            | 或　　　二进制解释，相同位，只要有1就得1，无1得0

            ~取反　　二进制解释，相同位 不同得1，相同得0

            ^ 异或  　二进制解释　 相同位 相同得0  不同得1

            左移 ： m<<n  　　m*2的n次方

            右移 ：m>>n 　　m//2的n次方  得数向下取整

  　　#三目运算符

            a=5 

            b=6

            result = (a-b) if a>b else (b-a)

        #range

            range(8);  0~7 

            range(0,8) ; 0~7

 　　 #for循环

            for  i in range(8):

                print('x')

            else:

                #占位 pass

                pass 

            print('y')

　　　

        #元组  type（元组）= tuple   特点：元组内元素不能修改

            name = ('1',)    #元组内部只有一个元素时，后面要加上逗号  ,   否则会默认为str字符串

        #将列表倒序  list[::-1]

        #查找列表中 list[2:-3]   从第2个开始，截取到倒数第三个元素

        #求最大值max()   求最小值min()   求和sum()   求长度len()

        #元组中的函数  index()  count()

            tuple.index(4)   在tuple中找到元素4的下标位置

            tuple.count(4)   在tuple中所有元素为4的个数

        #  *a   *_     0到多个  放入列表[ ]中 拆包与装包

            tuple = (1,2,3,4)

            a,*b,c = tuple

            ===> print(a,b,c)        ==>   a = 1    b = [2,3]    c = 4 

            ===> print(*b)   ==>   2 3 

        # in ;    not in ; 

            print(1 in (1,2)) ==> true

 

        # sorted()  排序，返回一个列表

        #强制类型转换  tuple() list()

        #list 列表   tuple元组   dict字典  

            dict2 = dict()

        #字典里面的函数  

            items()   

            values() 

            keys()   

            get()    

                1、dict2.get('张三'，28)  如果没有查找到张三，则设置默认值28

                2、dict2.get('张三')  取出字典中的keys 张三

            remove()        删除，如果不存在会报错

            pop()   删除，如果不存在不报错。如果删除成功，返回删除项的值。

        #定义函数 

            def  add(*a)   #可变参数

            print(a)   ==> a ==>  () 是个元组 

        # print(locals())   打印函数内所有的变量

        # nonlocal  与  global  

            nonlocal  只能在嵌套内层函数中修饰变量

            nonlocal a   变量a为自由变量，可以保存在闭包中。

        #装饰器   函数作为参数给另外一个函数

            　　def funA(funX) :

            　　　　print('1')

            　　　　def funB(*arg,**kwargs):  　　#*arg对应多个参数，**kargs对应字典参数

            　　　　　　time.sleep(2)   　　　　#休眠2秒，需要import time

            　　　　　　print("B")

            　　　　　　funX(*arg,**kwargs)

            　　　　return funB 

　　　　　　#参数为字符

            　　@funA   

           　　 def funChar(a):

           　　　　print(a)

            　　funChar(a)

 

　　　　　　#参数为字符串

           　　 @funA   

            　　def funStr(str):

            　　　　print(str)

            　　funStr('1991')

　　

　　　　　　#参数为列表

            　　@funA   

            　　def funList(list):

            　　　　for i in list

            　　　　print( i )

           　　 list  = ['xx','xx','xx'] 

            　　funList(list)

　　　　

　　　　　　#参数为关键字

           　　 @funA   

           　　 def funDict(list, clazz='1991' )  #如果不传，则默认参数1991

            　　　　print(clazz)

            　　　　for i in list

            　　　　　　print( i )

        　　    list  = ['xx','xx','xx'] 

         　　   funDict(list , 1990) #如果传，则参数1990

           　　 funDict(list)   #如果不传，则默认参数1991

        #多次装饰

            def funFirst(func):

            　　def xxxx(*args, **kwargs):

           　　　　 func(*args)

       　　　 　　print(...do something1...)

            　　return xxxx

            def funSecond(func):

            　　def xxxx(*args, **kwargs):

            　　　　func(*args)

            　　　　print(...do something2...)

            　　return xxxx

            @funSecond

            @funFirst   #哪个装饰器离得近，哪一个就先发挥作用。

            def funxxx(args):

            　　print('...do something funxxx...'.format(args) )

 

　　　  funxxx(args)

        #装饰器传参  3层装饰

            #第一步定义三层装饰器 

            def funFirst(xxxx):                 # 第一层传递装饰器的参数

            　　def funSecond(funUse):              #第二层传递装饰器装饰的函数

           　　 　　print("use {}".format( xxxx )           

           　　　　 def funThird(*args, **kwargs):          #第三层传递装饰器装饰的函数的参数

           　　　　　　 funUse(*args)

            　　　　return funThird

            　　return funSecond

            #第二步装饰器传参  并且定义使用装饰器的函数

            @funFirst(xxxx = 100)               

            def funUse(yyyy):

            　　print('use {}'.format(yyyy) )

            #第三步 调用函数，并传参

            funUse(300)

        #函数作用域：L  E G B     

            L    local      本地的，局部的变量

            E   encloseing  嵌套

            G   global  全局变量

            B   built-in    内置的变量