文章目录

一，Python基础
- 1.1，Python特性
- 1.2，特点
- 1.3，运算符
- 1.4，变量类型
- 1.5，字符串
- 1.5，math库
- 1.7，string库
- 1.8，正则表达式
二，常用数据结构
- 2.1，列表List[ ]有序可变
- 2.2，元组Tuple（）有序不可变
- 2.3，字典dict{ : }无序可变
- 2.4，集合set{}无序不重可变
- 2.5，推导式
三，流程控制&面向对象编程
- 3.1，流程控制—-分支结构
- 3.2，流程控制—-循环结构
- 3.3，函数
- 3.4，变量作用域
- 3.5，类
- 3.6，模块：
- 3.7，面向对象基础
四，
- 4.1，文件和异常
- 4.2，正则表达式
- 5.1，os操作
- 4.3，进程和线程
- 4.4，数据结构和算法

文档链接：

官方文档
中文教程
刘江博客
博学谷项目
Django零基础
Python核心编程

编辑工具：

iPython
jupyter notebook
sublime text
Pycharm
Pip
颜色

一，Python基础

1.1，Python特性

在这里插入图片描述

1.2，特点

在这里插入图片描述

1.3，运算符

在这里插入图片描述

1.4，变量类型

在这里插入图片描述

1.5，字符串

在这里插入图片描述

1.5，math库

在这里插入图片描述

1.7，string库

在这里插入图片描述

1.8，正则表达式

在这里插入图片描述

二，常用数据结构

2.1，列表List[ ]有序可变

在这里插入图片描述

2.2，元组Tuple（）有序不可变

在这里插入图片描述

2.3，字典dict{ : }无序可变

在这里插入图片描述

2.4，集合set{}无序不重可变

在这里插入图片描述

2.5，推导式

在这里插入图片描述

result = [lambda x: x + i for i in range(10)]
print(result[0](10))  //0~9 都是19  因为函数具有调用时才查找变量的特性
result = [lambda x, i=i: x + i for i in range(10)]
print(result[0](10))  //0~9  10~19

三，流程控制&面向对象编程

3.1，流程控制—分支结构

在这里插入图片描述

3.2，流程控制—循环结构

在这里插入图片描述

3.3，函数

在这里插入图片描述

def func(a=[]):
    print("函数内部a的地址为：%s" % id(a))   
    a.append("A")   
    return a
b = func()                                #函数内部a的地址为：39287880
print('此时b的值为：%s' % b)              #此时b的值为：['A']
print("函数外部b的地址为：%s" % id(b))    #函数外部b的地址为：39287880
print("-------------")
c = func()                                #函数内部a的地址为：39287880 
print('此时c的值为：%s' % c)              #此时c的值为：['A', 'A']
print("函数外部c的地址为：%s" % id(c))    #函数外部c的地址为：39287880
print("-------------")
def func(a=[]):
    a.append("A")
    return a
#我们导入的模块除了定义函数之外还中有可以执行代码，那么Python解释器在导入这个模块时就会执行这些代码
#事实上我们可能并不希望如此，因此如果我们在模块中编写了执行代码，最好是将这些执行代码放入如下所示的条件中
if __name__ == '__main__':
    print(func())  //["A"]
    print(func())  //["A","A"]
    print(func())  //["A","A","A"]

3.4，变量作用域

if不包括作用域，以函数为例，层层向上找，函数外不可调用函数内部变量
global a：将函数内部变量调用最外层变量 nonlocal：将函数内部变量调用上一层变量

a=1 b=1 c=1
print(a,b,c)  //1,1,1
def fun():
   a=2 b=2 c=2 
   def fun1():
      noniocal b  b=3 global c c=3
      print(a,b,c) //2,3,3
   print(a,b,c)  //2,3,2
print(a,b,c)  //1,1,3
   fun1()
fun()
a = 10
def test():
    a += 1
    print(a)
test()  //错误，函数内部要修改一个变量，这个变量必须是内部变量

3.5，类

class 类名(列表)：
方法：类中的函数
属性：通过实例访问的对象，私有属性，__属性名
创建调用：a=Dog(‘we’,3) a.方法名()
继承： class 子类名（父类名）： //多继承，可继承多个父类
创建子类时，父类必须包含在当前文件中，且在子类前

class Test:
    def __init__(self, foo):
        self.__foo = foo
    def __bar(self):
        print(self.__foo)
        print('__bar')
def main():
    test = Test('hello')  #类调用
    test._Test__bar()
    print(test._Test__foo)
if __name__ == "__main__":
    main()

3.6，模块：

包：包名小写，不用下划线，只有包含__init__.py的文件才会被认成包
封装：代码快，函数，类，模块，包，层层封装调用
模块：一个.py文件即一个模块，分为自定义/内置/第三方模块
导入：【from xx】 import xx/os库名，，，【as xx】
调用：模块名.函数名
导入特定的函数：from 模块名 import 函数名，函数名，函数名 as 别名
别名：as //函数名冲突，或过长
print dir(模块名) //查看已引入的模块的所有属性
导入模块时，先在当前目录查找，再到sys模块的path变量所指定的目录查找

3.7，面向对象基础

特点：封装，继承，多态
其它：类是对象的蓝图和模板，而对象是类的实例
装饰器：@property #使类中的属性访问更加安全
方法：静态方法（类中方法前+@staticmethod，判断三边能否构成三角形）
类方法（类中方法前+@classmethod，def now(cls):方法参数固定cls）
类之间关系：继承is-a（男人–人），关联has-a（部门–员工），依赖use-a（司机-驾驶->车子）
重写：子类在继承了父类的方法后，可以对父类已有的方法给出新的实现版本（override）
多态：重写让父类的同一个行为在子类中拥有不同的实现，调用重写方法，不同子类表现不同

class Person(object):
    __slots__ = ('_name', '_age', '_gender')  # 限定Person对象只能绑定_name, _age和_gender属性
    def __init__(self, name, age):
        self._name = name
        self._age = age
    @property   # 访问器 - getter方法
    def name(self):
        return self._name
    @property    # 访问器 - getter方法
    def age(self):
        return self._age
    @age.setter   # 修改器 - setter方法
    def age(self, age):
        self._age = age
    def play(self):
        if self._age <= 16:
            print('%s正在玩飞行棋.' % self._name)
        else:
            print('%s正在玩斗地主.' % self._name)
def main():
    person = Person('王大锤', 12)
    person.play()
    person.age = 22
    person.play()
    # person.name = '白元芳' # AttributeError: can't set attribute
if __name__ == '__main__':
    main()

四，

4.1，文件和异常

定义：用于持久化场景中的数据保存 f=open(‘bb.txt’,‘r’)
模式：‘r’ 读 ‘w’ 写 ‘x’ 写 ‘a’ 追加 ‘b’ 二进制 ‘t’ 文本 ‘+’ 更新（读+写）
read(): 读取文件，达到文件末尾时会返回一个空字符串，显示出来为空行
readline():读取一行 //PS具体写法json,二进制，参考100篇
使用相对路径/绝对路径来编写： a=’/home/dd/erjl/a.txt’ with open(a) as bb:

def main(): 
    try:   #with则不用finally去关闭f文件
        with open('致橡树.txt', 'r', encoding='utf-8') as f: #一次性读取
             print(f.read())      
        with open('致橡树.txt', mode='r') as f:   # 通过for-in循环逐行读取
            for line in f:
                print(line, end='')
                time.sleep(0.5)
    except FileNotFoundError:
        print('无法打开指定的文件!')
    except LookupError:
        print('指定了未知的编码!')
    except UnicodeDecodeError:
        print('读取文件时解码错误!')
# finally: #无论如何总执行
# if f:
# f.close()
if __name__ == '__main__':
    main()