基本语法

  1. 注释
    1. 单行注释以 # 开头
    2. 多行注释 以''' ''' 三个单引号
  2. 对大小写敏感
  3. print输出，input输入
    1. print默认是换行输出
    2. 关键字end，将多个结果放在同一行输出，并指定多个结果之间的分隔符，如print(x, end=",")
    3. print("x的值为：", x)输出辅助文字

  4. 代码组，首行以关键字开始 以:结束，同一个代码组的每一行缩进相同

基本数据类型

  1. Number、String、List、Tuple(元祖)、Set(集合)、Dictionary(字典)
  2. Python中变量没有类型，以上所指的类型是变量在内存中的类型
  3. Python可以同时为多个变量赋值，如a, b = 1, 2.5

数字 Number

  1. Python3中支持：int、float、bool、complex（复数，如1+3i）
  2. 可以使用type(a)查看变量a的类型，或使用isinstance(a, int)查看变量a的类型是int或int的子类
  3. Python3中增加的bool类型，其关键字True和False的值与1和0相同
  4. 除法 2 / 4 得到浮点数；2 // 4 得到整数；2 % 4 取余。2 ** 5 乘方
  5. 数字类型转换
    1. int(a) 将a转化为整数
    2. float(a) 将a转化为浮点数
    3. complex(a) 将a转化为复数
    4. complex(a,b) a为实部，b为虚部

字符串 String

  1. 对于字符串，单引号和双引号的使用相同
  2. 没有单独的字符类型，一个字符就是长度为1的字符串
  3. 字符串截取：变量名[头下标：尾下标：步长]，且是左闭右开区间 [ )（即不会输出尾下标元素）
  4. 索引方式：从左至右以0开始；从右至左以-1开始
  5. 字符串可以用+连接，用*运算符重复
  6. 使用\加一个特定字符表示转义，防止转义可以在字符串前加上 r 或 R，如r"hello\n Naka"
  7. 字符串的值不可以被改变
  8. 字符串的比较 >, <, >=, <=, ==, !=

列表 List

  1. 写在方括号[]中，用逗号分隔，每个元素数据类型可不一样
  2. 可以同字符串一样进行 索引、切片、串联+
  3. 列表元素可改变
  4. 列表生成式 li = [ 2*i for i in range(10)]

元组 Tuple

  1. 写在小括号()中，逗号分隔，元素类型可不一样，有序
  2. 可以同字符串一样进行 索引、切片、拼接+
  3. 元素不可改变，但元素可以包含可变数据类型List
  4. 空元组 tup = ()；一个元素的元组 tup = (1, ) 需要加一个逗号
  5. 删除元组 del tup
  6. 查看长度 len(tup)
  7. 将列表转为元组 tuple(list)

集合 Set

  1. 集合是一个无序不重复的元素集，可用来消除重复元素
  2. 创建 a = set() b = set('ajjjien') c = {'a', 'b', 'c'}
  3. 基本操作
    1. 新增 add() update()
    2. 删除 remove() discard() pop() clear()
  4. 是否是子集
    1. s2.issubset(s1) True s2是s1的子集
  5. 是否是超集
    1. s1.isseuperset(s2) True s1是s2的超集
  6. 是否有交集 s2.isdisjoint(s1) 有交集为 False
  7. 数学运算
    1. 求交集 s1.intersetion(s2) s1 & s2
    2. 求并集 s1.union(s2) s1 | s2
    3. 求差集 s1.difference(s2) s1-s2
    4. 对称差集 s1.symmetric_difference(s2) s1 ^ s2 即并集减去交集
  8. 集合生成式 se = { i*i for i in range(10)}

字典 Dictionaries

  1. 字典是一种映射类型，由键值对组成，‘键’必须是不可变类型且不可重复
  2. 创建 a = {} b = {'a':1109, 'b':0934}
  3. 访问 b['a']
  4. 添加 b['c'] = "Nakamura"
  5. 元素值可修改
  6. 删除元素 del b['a']
  7. 很多构建字典的方法。。。
  8. 一些内置函数
    1. len(dict) 元素个数
    2. str(dict) 以字符串输出
数据结构 是否可变 是否可重复 是否有序 定义符号
列表 List 可变 可重复 有序 [ ]
元组 Tuple 不可变 可重复 有序 ( )
字典 Dictionary 可变 key不可重复 无序 {key: value}
集合 Set 可变 不可重复 无序 { }

运算符

成员运算符

  1. in
  2. not in

身份运算符

  1. is

  2. not is

    逻辑运算符（区别）

  3. and

  4. or
  5. not

条件控制

没有switch-case语句

if elif else

  1. if c1:
  2.     s1
  3. elif c2:
  4.     s2
  5. else:
  6.     s3

循环

for

  1. for 一个东西 in 一个东西:
  2.     语句1
  3. else :
  4.     语句2

  • range()函数，遍历数字序列 在一定数字范围内遍历

    1. for i in range(5):
    2.   print(i)
    3. 输出 0 1 2 3 4
    • 指定区间 range(2,6)
    • 指定步长 range(3,9,2)

while

  1. while c:
  2.     s

break continue

迭代器

函数

  1. 定义 创建

    1. def func_name():
    2.  函数体
    3.  [return xxx]

  2. 变量的作用域

    1. 局部变量，定义在函数内部，若使用global声明 则变为全局变量
    2. 全局变量，定义在函数外部，可作用于函数内外


  4. 递归函数

  5. 定义

  6. 求斐波那契第n个数 1, 1, 2, 3, 5, 8... ```python

    普遍写法

    def fib(n): if n == 1:
    1.  return 1
    elif n == 2:
    1.  return 1
    else:
    1.  return fib(n-1) + fib(n-2)
    fib(20)

我想的写法

a, b = 0, 1 def fibN(a, b, n): if n <= 2: return a+b return fibN(b, a+b, n-1)

print(fibN(0,1,20))

  2. 3. 返回多个值时以元组形式返回
  4. <a name="JUqf5"></a>
  5. # 类和对象
  7. 1. 定义。Python里面一切皆对象
  8. 1. 面向对象的三大特征：封装、继承、多态
  9. 1. 创建
  10.    1. Python将类属性设置私有是 在初始化函数内在该属性前加两个`_` 
  11. ```python
  12. class ClassName: 
  13.     my_name = '悠一'   # 类属性
  14.     def __init__(self, name, age):  # 初始化
  15.         self.name = name
  16.         self.__age = age         # 将age属性变为私有
  18.     def place(self):   # 实例方法
  19.         print('Ty')
  21.     @staticmethod
  22.     def sm():          # 静态方法，没有默认参数，使用类名调用
  23.         print('wwww') 
  25.     @classmethod
  26.     def cm(cls):       # 类方法，使用类名调用
  27.         print('wo')
  1. 只创建一个类时，这个类也是一个对象 会被分配内存空间。
  2. 创建实例对象 cn = ClassName('yukkan',41)
  3. 调用方法 cn.place() ClassName.place(cn) 。使用cn._ClassName__age 可以访问私有属性
  4. 动态绑定属性和方法
    1. 每个实例对象的属性和方法可以不同
    2. cn.pet = 'neco'
  5. 内置函数dir(对象名) 可以查看对象的所有属性

继承

  1. 语法：class 子类(父类1, 父类2):
  2. 类默认继承Object类
  3. 定义子类时，必须在其构造函数中调用父类的构造函数
    1. class ClassName:
    2.  my_name = '悠一' 
    3.  def __init__(self, name, age): 
    4.      self.name = name
    5.      self.__age = age  
    6.  def place(self): 
    7.      print('Ty')
    8. class Son(ClassName):
    9.  def __init__(self, name, age, car):
    10.      super().__init__(name, age)   # 调用父类的构造函数初始化属性
    11.      self.car = car

重写

  1. 重写父类同名的方法 ```python class ClassName: my_name = ‘悠一’

    def init(self, name, age): 

    1.  self.name = name
    2.  self.__age = age

    def place(self): 

    1.  print('Ty')

class Son(ClassName): def init(self, name, age, car): super().init(name, age) self.car = car def place(self): super().place() # 调用父类的同名方法 print(“oosaka”)

  2. <a name="Vt7kL"></a>
  3. ## 多态
  5. 1. 子类重写了父类的方法后，实现时 根据变量所引用的类型，动态决定调用哪个对象中的方法
  6. ```python
  7. class Animal:
  8.     def eat(self):
  9.         print("an animal is eating")
  10. class Dog(Animal):
  11.     def eat(self):
  12.         print("a dog is eating")
  13. class Cat(Animal):
  14.     def eat(self):
  15.         print('a cat is eating')
  17. class Human:
  18.     def eat(self):
  19.         print('a human is eating')
  21. def test(obj):
  22.     obj.eat()
  24. test(Animal())
  25. test(Dog())
  26. test(Cat())
  27. test(Human())

类的特殊属性

  1. 对象.__dict__ 可以查看该对象所绑定的属性及其值
  2. 对象.__class__ 查看该对象所属的类
  3. 类.__bases__ 查看该类的父类
  4. 类.__mro__ 查看该类的层次结构
  5. 类.__subclasses__() 查看子类

特殊方法

  1. 将两个对象的属性相加
    1. class Person():
    2.  def __init__(self, name):
    3.      self.name = name
    4.  def __add__(self, other):
    5.      return self.name+other.name
    6. p1 = Person("sugita")
    7. p2 = Person("kamayaki")
    8. print(p1+p2)

深拷贝与浅拷贝

  1. 变量的赋值操作 定义了两个变量，实际上指向的是同一个对象（同一个地址）
  2. 浅拷贝 对象包含的内容不拷贝，只拷贝原对象 ```python class CPU: pass class Disk: pass class Computer: def init(self, cpu, disk):
    1.  self.cpu = cpu
    2.  self.disk = disk

cpu1 = CPU() disk1 = Disk()

cpu2 = cpu1 # 赋值，两个对象指向同一个地址

computer1 = Computer(cpu1, disk1)

import copy computer2 = copy.copy(computer1) #浅拷贝 为computer2开辟了一个新的地址

浅拷贝之后，computer1和computer2所指向的地址不同，但它们的内容（cpu和disk）所指向的地址相同

  2. 3. **深拷贝**     使用copy模块中的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同
  6. <a name="RVysP"></a>
  7. # 模块
  9. 1. 以`.py`结尾的文件就是一个模块
  10. 1. 使用 
  11.    1. 导入  `import 名称 [as 别名]`  `from 模块名称 import 函数、变量、类`
  12. 3. 导入自己的模块方式 [链接](https://blog.csdn.net/qq_16069457/article/details/98791035)
  14. <a name="E09sz"></a>
  15. ## 顶级模块
  17. - 如果一个模块不是被导入到其他模块中执行，则它可能在解释器的顶级模块中执行。
  18. - 每个模块的定义中都包括一个记录模块名称的变量`__name__` 
  19. - 若模块在顶级模块中执行，则`__name__ = '__main__'` ，这样可以判断该模块是否被其他模块调用而执行
  20. ```python
  21. # module1.py
  22. def add(a, b):
  23.     return a+b
  25. if __name__ == '__main__':
  26.     print(add(20, 40))
  • 当其他模块导入module1.py，且执行它的add函数时，该模块会被执行。当前加上了名称判断，if语句模块中的部分只有在 module1.py 被点击执行时才执行

包 package

  • 包是将一组功能相近的模块的组合
  • 包中包含了__init__.py 文件

  • 包的导入 import 包.模块 from 包 import 模块

  • Python的内置模块 sys time os calendar urllib json re math decimal logging

第三方模块

  1. 安装 pip install 模块名