Python学习笔记(一)
本文最后更新于 198 天前,其中的信息可能已经有所发展或是发生改变。

1.Python缩进

elements = ["Tom","Jack","Anne"]
for elem in elements:
    print("Hello",elem) #缩进表示一个代码块
    print("I love you",elem)
print("Bye My",elements)#不缩进代表一个独立的语句,不在for循环体内

2.基本类型

  • 整数

  • 浮点数

    1.23e9可以表示很大的浮点数

  • 字符串

    可以使用"或者'括起来的,字符串内可用转义字符\标识

  • 布尔值

    TrueFalse 布尔值还可以用布尔运算,有三种:and,or, not与之对应的逻辑是数理逻辑上的与或非

  • 空值

    是Python一个特殊值,用 None表示

  • 列表、字典等

2.1变量

大小写英文、数字和_的组合,且不能用数字开头

2.2常量

Python里通常用全大写变量名表示常量,但不强制

2.3字符串编码

  • Python3采用Unicode编码,常见计算机系统内存统一采用Unicode编码,当需要保存到硬盘或者传输时,就转化为UTF-8编码,反之转化回Unicode。

  • Python对于 bytes 类型的数据用带 b 前缀的单引号或双引号表示:

    x = b'ABC'
  • 字符串可用encode( )方法可以编码为指定的bytes

    >>> 'ABC'.encode('ascii')
    b'ABC'
    >>> '中文'.encode('utf-8')
    b'\xe4\xb8\xad\xe6\x96\x87'
    >>> '中文'.encode('ascii')
  • len( )函数计算str字符数

    >>> print(len("你好"))
    2
    >>> print(len("nihao"))
    5

    如果是计算bytes,则是字节数

    >>> len(b'ABC')
    3
    >>> len(b'\xe4\xb8\xad\xe6\x96\x87')
    6
    >>> len('中文'.encode('utf-8'))
    6

    坚持使用UTF-8编码避免乱码问题

3.格式化

>>> print("hello ,%s,I'm %d years old,my score is %f"%("jack",18,95.00))
hello ,jack,I'm 18 years old,my score is 95.000000

另外一种是str.format( )方法,不推荐

4.list 和tuple

  • list是一种有序的集合,可以增删,

    elements = ["A",123,["C","D"],True]
    elements.append("abcd")
    elements.insert(2,("2","3"))
    elements.pop(0)
    print(elements)
    print(elements[-3][0])#如果是elements[-2][0]会报TypeErrorw
    ###########输出结果自行理解
    [123, ('2', '3'), ['C', 'D'], True, 'abcd']
    C
  • tuple一旦初始化不能修改,没有append( ), insert( )这种方法,能使用-1...表示索引

    tuple用 () 表示(注意和数学符号意义上的区别,通常用 , 如( 1,)加以区分)

    tuple里面若有指向别的元素如list,指向的list不可改变,但是list指向的可以改变

    tuple = ("A", "B", ["C","D"])#tuple里面的元素["C","D"]是一个list,list可以改变

5.dict和set

  • dict

6.Python小结

列表list []、元组tuple ()、字典 dict {key: value}、无序不重复集合 set (list[])

7.函数

  • 参数

    • 位置参数

    平时常用的按照顺序进行传参的参数

    def power(x,n):
        temp = 1
        if n<0:
            for t in range(n,0):#t表示n到-1的整数
                temp = temp/x
        elif n>0:
            for t in range(0,n):#range(n,m)表示返回n到m-1的整数list
                temp = temp*x
        return temp
    print("power(5,3):",power(5,3))#power(5,3): 125
    print("power(5,-2):",power(5,-2))#power(5,-2): 0.04
    • 默认参数

    默认参数在后面,默认参数必须指向不变对象,不然下次调用时默认参数内容就变了

    def enroll(name,age,city="北京",sex="保密"):
        print("My name is ",name,",I`m ",age)
        print("I`m come from ",city,",my sex is",sex)
    enroll("李华",23,sex = "女")
    #My name is  李华 ,I`m  23 
    #I`m come from  北京 ,my sex is 女   
    enroll("张三",18)
    #My name is  张三 ,I`m  18
    #I`m come from  北京 ,my sex is 保密  
    enroll("李四",45,"上海","男")
    #My name is  李四 ,I`m  45
    #I`m come from  上海 ,my sex is 男  
    
    • 可变参数

    在参数前加一个 * ,参数接收到的可以是一个tuple,也可以是任意个参数包括0个

    对于已有的tuple和list,在前面加一个 * 就可变成可变参数传入函数

    def calc(*numbers):
        sum = 0
        for number in numbers:
            sum = sum + number
        return sum
    nums1 = [1,3,5,7]
    nums2 = (1,3,5,7)
    print(calc(1,3,5,7)) #16
    print(calc(*nums2))  #16
    print(calc(*nums1))  #16
    • 关键字参数

    允许传入0至多个参数,在函数内部自动组装为一个dict

    def info(name, age, **more):
        print(name," ",age," ",more)
        if "city" in more:
            pass 
        if "addr" in more:
            print("my city:",more.get("addr")) #more相当于一个字典
    
    info("李华",12,addr="钦州市",sex = "男")
    #结果都为:李华   12   {'addr': '钦州市', 'sex': '男'} my city: 钦州市
    extra = { "addr":"钦州市","sex":"男"}
    info("李华",12,**extra)#这里相当于把extra的一份拷贝给函数info的关键字参数more

    小结:对于任意函数,都可以通过类似func(*args, **kw)的形式调用它,无论它的参数是如何定义的。

  • 递归

  • 元信息

    #为函数添加元数据,描述函数的参数类型和返回类型
    def add(x:int, y:int) -> int:
      return x+y

    元信息只是为了帮助源码阅读。python解释器不会对这些注解添加任何的语义。即使返回类型不一致,程序也不会出错,因为它们不会被类型检查。

8.高级特性

  • 切片

    : 用来取list或tuple的部分元素

    L = list(range(100,200))
    print(L[:3])#取list前三个元素
    print(L[1:3])#取list中索引值为1到索引值为3的元素
    print(L[-20:-10])#取倒数第十到倒数第二十也就是180-190(不包括190)之间的十个整数
    print(L[:10:2])#前十个元素,每隔2个元素取一个,结果为100,102,104,106,108
    print(L[::-1])#实现切片逆序
  • 迭代

    1、 通过for...in来完成迭代,不仅可以在 tuplelistdict 上进行迭代,还可以作用于可迭代对象(可通过collections.abc 模块的 Iterable 类型判断)

    >>>isinstance('abc',Iterable)#str是否能迭代
    True
    >>>isinstance(123,Iterable)#整数是否能迭代
    False

    2、实现Java下标循环

    >>>for i,x in enumerate(['A','B','C']):
    >>>    print(i,x)
    0 A
    1 B
    2 C
  • 列表生成式

    1. 列表生成式可以嵌套一层至多层循环

      #列表生成式直接一行代码生成list
      >>>print([x*x for x in range(1,5)])
      [1,4,9,16]
      #还可以使用像for循环那样的两个变量即以上
      >>>dictItem = {'A':'a','B':'b','C':'c'}
      >>>print([a+'='+b for a,b in dictItem.items])
      ['A=a','B=b','C=c']
      #for循环后还能添加if判断条件,注意!!这是筛选条件,和下面的if...else不一样
      >>>print([x*x for x in range(1,10) if x%2==0])
      [4, 16, 36, 64]
      #还可以添加多层循环
      >>>print([a+b for a in ['1','2','3'] for b in ['A','B','C']])
      ['1A', '1B', '1C', '2A', '2B', '2C', '3A', '3B', '3C']
    2. if...else的使用(使用方法为在for循环前加上if...else)

      >>>dictItem = {'A':2,'B':'b','C':'c','D':3}
      >>>print([a+'='+b if isinstance(b,str) else a+'='+str(b) for a,b in dictItem.items()])
      ['A=2', 'B=b', 'C=c','D=3']
  • 生成器(Generator)

    next()yelidStopIteration

    generator函数返回一个generator对象

9. 高阶函数

  • map()reduce()filter()

    1. map()

      接收一个函数和Iterator,将函数作用到所有Iterator元素上并将结果返回到新的Iterator,最终结果返回新的Iterator。

      >>> def f(x):
           return x * x
      >>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
      >>> list(r)#最后要用list函数将Iterator转换为list
      [1, 4, 9, 16, 25, 36, 49, 64, 81]
    2. reduce

      接收一个函数和一个序列,该函数必须接收两个参数reduce 负责将函数结果继续和 序列下一个元素 作为两个参数继续执行下一次函数,直到后序无元素,最终结果为计算结果

      >>>def add(x,y):
      >>>    return x+y
      >>>reduce(add,[1,3,5,7])
      16

    思考题:利用mapreduce编写一个str2float函数,把字符串'123.456'转换成浮点数123.456

    1. filter

      接收一个函数和一个序列,将 函数作用于每个元素 ,然后根据返回值是 True 还是 False 决定保留或者丢弃元素。

      >>>def not_empty(s):
      >>>    return s and s.strip()
      >>>print(list(filter(not_empty,['A',None,'B','']))
      ['A', 'B']
  • sorted()

    sorted() 可以对list进行排序,也是一个高阶函数,可以接收一个 key 函数自定义排序顺序

    >>>sorted([9,-1,2,4,-5],key=abs)
    [-1, 2, 4, -5, 9]

    sorted()函数负责将key函数返回的结果进行排序,并按对应关系返回list中的元素

    此外,要实现反向排序还可以传入 reverse 的值为 True

    >>>print(sorted([9,-1,2,4,-5],key=abs,reverse=True))
    [9, -5, 4, 2, -1]

    sorted() 返回结果为list

10. 函数式编程

  • 返回函数

    1. 一个函数可以返回值,也可以返回函数

      def  lazy_sum(L):
        def sum(L):
               result = 0
               for x in L:
                   result = result + x
               return result
        return sum #注意返回sum和sum()的区别!!!
      test = lazy_sum([1,2,3,4,5])
      print(test())#返回的是sum,则需要调用test();如果返回的是sum(),则直接调用test

      ​ 上述例子,如果函数内只是返回函数名而不是返回执行函数,则为 闭包运算 ;此外,返回闭包时,要注意返回函数不能引用任何循环变量或者后续会发生变化的变量。

    2. nonlocal

      声明该变量不是当前函数的局部变量

  • 匿名函数(lambda)

    关键字 lambda 参数 x,y : 函数返回值 x+y

    lambda x,y: x+y 

    多数时候配合高阶函数 map()filter()reduce()sorted() 使用

  • 装饰器(decorator)

    在代码运行期间动态增加功能的方式。(动态语言的函数和类的定义,是在运行时动态创建的。)

    要借助Python的 @ 语法,把decorator放在函数 定义处

    import time
    
    def log(func):
      def wrapper(*args,**kw):
          print('call %s()'%func.__name__)
          return func(*args,**kw)
      return wrapper
    @log   #相当于执行 now = log(now)
    def now():
      print(time.strftime("%Y-%m-%d %H:%M:%S"))
  • 偏函数

    当函数的参数个数太多,需要简化时,使用functools.partial可以创建一个新的函数,这个新函数可以固定住原函数的部分参数,从而在调用时更简单

    >>> import functools
    >>> int2 = functools.partial(int, base=2)
    >>> int2('1000000')
    64
    >>> int2('1010101')
    85

11. 模块

  • 作用域

    _xxx 或者 _xxx_ 表示的 函数 或者 变量 一般为非公开的(private),不应该被直接引用(但依然可以在其它模块强制引用)。

    #这是工具类.py模块
    >>>import datetime
    >>>import time
    >>>def showtime():
    >>>    print(time.strftime("%Y-%m-%d %H:%M:%S"))
    >>>__t = time.strftime("%Y")
    >>>def __showyear():
    >>>    print(__t)
    
    #这是test.py模块
    >>>from 工具类 import showtime,__showyear,__t
    >>>showtime()
    >>>print(__t)#不推荐直接使用其它模块的private变量或函数,即使可以正常使用
    >>>__showyear()
    2022-02-26 18:36:49
    2022
    2022

    只有外部需要的函数或者变量才定义为public。

  • 安装第三方模块

    包管理工具 pip

12.面向对象编程

  • 类和实例及其访问权限

    #新建Student类,并继承Object类
    class Student(object):
      #__init__方法初始化对象,相当于java的构造子
      #定义类时,self代表"实例的引用"
      def __init__(self, name, gender):
      #__xxx习惯上设置访问权限为private,但还是可以强制访问
          self.__name = name
          self.__gender = gender
      #设置对象里的方法
      def get_gender(self):
          return self.__gender
    
      def set_gender(self,s):
          if s =='male'or'female':
              print(self.__gender)
              self.__gender = s
              print(self.__gender)
          else:
              raise ValueError('值错啦')
    # 测试:
    bart = Student('Bart', 'male')
    if bart.get_gender() != 'male':
      print('测试失败!')
    else:
      bart.set_gender('female')
      if bart.get_gender() != 'female':
          print('测试失败!')
      else:
          print('测试成功!')
  • 方法

    Python中的方法分为三种:实例方法、类方法、静态方法。

    • 实例方法

    参数里面有 self ,如:

    def set_self(self,name):
        self.__name = name
    • 类方法

    前面带有装饰器 @classmethod ,且参数里面有 cls ,如:

    @classmethod
    def class_func(cls):
        cls.name = "我是类名"
        print("my name is %s"%(cls.name))
    • 静态方法

    形参中没有 clsself,甚至没有参数,如:

    import random
    @staticmethod
    def static_func():
        #返回0-9的随机数
        randomNum = random.randint(0,9)
        return randomNum

    类方法和静态方法都可以通过类名和实例名调用

  • 获取对象信息

    1. type()方法

      >>> type(123)==int
      True
      >>> type('abc')==type('123')
      True
      >>> type('abc')==str
      True

      该方法返回对应的Class类型

    2. id()方法

      >>>str1 = 'test'
      >>>str2 = "test"
      >>>str3 = str1
      >>>int1 = 123
      >>>list1 = [1,2,'3']
      >>>tuple1 = (1,2,3,[1,2,'3'])
      >>>total =['test',str2,str3,int1,list1,tuple1]
      >>>print(list(id(i) for i in total[:3] if >>>type(i)==str))
      >>>print(list(id(i) for i in total))
      [2408464217968, 2408464217968, 2408464217968]
      [2408464217968, 2408464217968, 2408464217968, 2408455690416, 2408507421120, 2408507410448]
      

      从输出结果可以看出程序运行时str1、str2、str3的id值是一样的

    3. isinstance()方法

      如果有继承关系:Object ->Animal ->Dog ->Husky

      那么则

      a = Animal()
      b = Dog()
      h = Husky()
      >>>isinstance(h,Husky)
      True
      >>>isinstance(h,Animal)
      True

      isinstance()还可以判断其类型及其子类,一般情况下优先使用isinstance()判断类型

      isinstance()还可以判断是否为某些变量其一

      >>> isinstance([1, 2, 3], (list, tuple))
      True
      >>> isinstance((1, 2, 3), (list, tuple))
      True
    4. __doc__属性

      >>>print(len.__doc__)
      Return the number of items in a container. 

      用于查看某对象支持的方法或属性清单

    此外还有 help()方法,可以帮助显示方法或属性信息

  • 类属性

    直接定义在类中,区别于实例属性self.xxx

  • 动态绑定

    动态绑定允许我们在程序运行的过程中动态给class加上功能

    class Student(object):
      def __init__(self,name):
          self.__name__ = name
    stu1 = Student('张三')
    #动态绑定给实例绑定一个属性
    stu1.sex = 'male'
    print(stu1.sex)
    # 动态绑定给实例绑定一个方法
    def  set_name(self,name):
      self.__name__ = name
    from types import MethodType
    stu1.set_name = MethodType(set_name, stu1) 
    stu1.set_name('李四')
    print(stu1.__name__)
    

    为了限制类外动态绑定属性或方法,可以定义在定义类时用__slots__变量,来限制该class实例能添加的属性。

    class Student(object):
      __slots__ = ('name','__name__')
      def __init__(self,name):
          self.__name__ = name

    此时如果向Student类添加sex属性则会报AttributeError

    image-20220312211908812

    注意__slots__定义的属性仅对当前类实例起作用,对继承的子类是不起作用

    练习:利用@property给一个Screen对象加上widthheight属性,以及一个只读属性resolution

    class Screen(object):
      @property
      def  width(self):
          return self.__width__ 
      @width.setter
      def width(self,size):
          if isinstance(size,(int,float))==False:
              raise TypeError('请输入正确的int或其它数值类型')
          if size < 0 or size > 2048:
              raise ValueError('请输入正确范围的数')
          self.__width__ = size
      @property
      def  height(self):
          return self.__height__
      @height.setter
      def height(self,size):
          if isinstance(size,(int,float))==False:
             raise TypeError('请输入正确的int或其它数值类型')
          if size < 0 or size > 2048:
             raise ValueError('请输入正确范围的数')
          self.__height__ = size   
      @property
      def  resolution(self):
          return self.__width__*self.__height__
  • 多重继承

    通过多重继承,一个子类就可以同时获得多个父类的所有功能

    class Dog(Mammal,Runnable):
      def __init__():
          pass

    MixIn 用于分清主父类和额外功能(类似于Java的继承单一父类和多继承接口)

    class Dog(Mammal,RunnableMixIn):
       def __init__():
          pass
  • __str__

    Python里面的 __str__ 相当于Java 的 toString()方法

    class Student(object):
      __slots__ = ('name','__name__')
      def __init__(self,name):
          self.__name__ = name
      def __str__(self) -> str:
          return 'my name is%s '%(self.__name__)
    stu1 = Student('张三')
    print(stu1)  #结果为:my name is 张三

    同样的还有 __getattr____call____iter____getitem__

    可根据需要前往官网文档查阅相关资料,不再赘述。

13. 异常、错误、调试

  • 错误与错误

    高级语言通常都内置了一套try...except...finally...的错误处理机制,Python也不例外

    try:
      #可能发生异常的语句
    except IOError as e :
      #发生IOError异常时要执行的语句
      print("An EOF error occurred.")
      raise e
    except (Ex2,Ex3):
      #发生异常Ex2或Ex3时要执行的语句
    except Exception:
      #发生其它异常时要执行的语句
    else:
      #无异常时要执行的语句
    finally:
      #无论有没有异常都要执行的语句
      #如文件资源、数据库、图形句柄资源的释放
  • 调试

    有三种方式:Python Debugger%xmodeassert

    Python学习笔记(二)

本人本着学习交流的态度,恳请大家友好留言。
内容为个人笔记和记录,不保证其正确性,请慎用。
如有不足,望指正。如有侵权,请在留言板联系我。
文章作者:秃秃不是兔兔,如需引用,请标注原文地址:https://wangwangyz.site/archives/253
暂无留言,来做第一个留言的人吧♥

发表评论 编辑评论


				

您的电子邮箱地址不会被公开,用于有回复时通知您。*为必填项

|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
(╯‵□′)╯︵┴─┴
 ̄﹃ ̄
(/ω\)
∠( ᐛ 」∠)_
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ`)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ( ̄∇ ̄o)
ヾ(´・ ・`。)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò。)
Σ(っ °Д °;)っ
( ,,´・ω・)ノ"(´っω・`。)
╮(╯▽╰)╭
o(*////▽////*)q
>﹏<
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
颜文字
Emoji
小恐龙
花!
上一篇
下一篇