? * print()
? * 关键字
* nonloacl 用来声明外层的局部变量
* global 用来声明全局变量
? * if 5 > 2:
print("You are right!")
else:
print("You are wrong!")
? * 注：缩进一定要，否则会出错
? * 注2：if 语句不能为空，但是如果您处于某种原因写了无内容的 if 语句，请使用 pass 语句来避免错误
## 3. 注释
? 1. 单行注释以 # 开头
? * 快捷键：Ctrl + /
? 2. 多行注释 """ """ 中间
?
## 4. 变量
? 1. x = 5
? 2. y = "Hello Word!"
? * 注：Python中没有声明变量的命令，直接用即可
? * Python 允许您在一行中为多个变量赋值：
? * 实例
? x, y, z = "Orange", "Banana", "Cherry"
? print(x)
? print(y)
? print(z)
? * 在一行中为多个变量分配相同的值：
? * 实例
? x = y = z = "Orange"
? print(x)
? print(y)
? print(z)
? 3. 可变变量
? * 先导入io
? import io
? s = ‘hello‘
? sio = io.StringIO(s)
? print(sio.getvalue()) #结果为 ‘hello‘
? sio.seek(4) #把光标移到第5个位子
? sio.write("r") #修改第5个位置的字符
? print(sio.getvalue()) #结果为 ‘hellr‘
## 5. 数据类型
? 1. Python 默认拥有以下内置数据类型：
? 文本类型： str
? 数值类型： int, float, complex
? 序列类型： list, tuple, range
? 映射类型： dict
? 集合类型： set, frozenset
? 布尔类型： bool
? 二进制类型： bytes, bytearray, memoryview
? 2. 可以使用 type() 函数获取任何对象的数据类型：
? * 实例
? x = 10
? print(type(x))
? 3. Python 随机数
? * Python 没有 random() 函数来创建随机数，但 Python 有一个名为 random 的内置模块，可用于生成随机数：
? * 实例
? 导入 random 模块，并显示 1 到 9 之间的随机数：
? import random
? print(random.randrange(1,10))
? 4. Python 字符串
? 1. 字符串变量可以使用单引号或双引号进行声明
? print("Hello")
? print(‘Hello‘)
? 2. 裁剪
? * 指定开始索引和结束索引，以冒号分隔，以返回字符串的一部分
? * 实例
? 获取从位置 2 到位置 5（不包括）的字符：
? b = "Hello, World!"
? print(b[2:5])
? 结果是：llo
? * 使用负索引从字符串末尾开始切片：
? * 实例
? 从倒数第5个字符开始，到倒数第2(不包含)个字符：
? b = "Hello, World!"
? print(b[-5:-2])
? 结果：orl
? 3. 内置函数
? 1. len() 函数返回字符串的长度：
? a = "Hello, World!"
? print(len(a))
? 2. strip() 方法删除开头或结尾的空白字符：
? a = " Hello, World! "
? print(a.strip()) # returns "Hello, World!"
? 3. lower() 返回小写的字符串：
? a = "Hello, World!"
? print(a.lower())
? 4. upper() 方法返回大写的字符串：
? 5. replace() 用另一段字符串来替换字符串：
? a = "Hello, World!"
? print(a.replace("World", "Kitty"))
? 6. split() 方法在找到分隔符的实例时将字符串拆分为子字符串：
? a = "Hello, World!"
? print(a.split(",")) # returns [‘Hello‘, ‘ World!‘]
? 4. 检查字符串
? * 如需检查字符串中是否存在特定短语或字符，我们可以使用 in 或 not in 关键字。
? * 实例
? 检查以下文本中是否存在短语 "ina"：
? txt = "China is a great country"
? x = "ina" in txt
? print(x)
? 5. 字符串格式：我们不能像这样组合字符串和数字，但是我们可以使用 format() 方法组合字符串和数字！
? * 实例
? age = 63
? txt = "My name is Bill, and I am {}"
? print(txt.format(age))
? * 注：format() 方法接受不限数量的参数，并放在各自的占位符中，可以使用索引号 {0} 来确保参数被放在正确的占位符中
## 6. 运算符
? 1. Python 逻辑运算符
? and or not
? 2. Python 身份运算符
? is is not
? 3. Python 成员运算符
? in not in
## 7. Python 集合（数组）
? * Python 编程语言中有四种集合数据类型：
? 1. 列表（List）是一种有序和可更改的集合。允许重复的成员。
? 列表是一个有序且可更改的集合。在 Python 中，列表用方括号编写[]。
? * a = [10,20,40,30]
? * a.sort() #默认升序排列 [10,20,30，40]
? * a.sort(reverse=True) #降序排列 [40,30,20,10]
? * import random
? * random.shuffle(a) #打乱顺序
? 2. 元组（Tuple）是一种有序且不可更改的集合。允许重复的成员。
? 元组是有序且不可更改的集合。在 Python 中，元组是用圆括号编写的。
? 3. 集合（Set）是一个无序和无索引的集合。没有重复的成员。
? 集合是无序和无索引的集合。在 Python 中，集合用花括号编写。
? * 集合的并交差
? * a|b 或 a.union(b) #并集
? * a&b 或 a.intersection(b) #交集
? * a-b 或 a.difference(b) #差集
? 4. 字典（Dictionary，及键值对）是一个无序，可变和有索引的集合。没有重复的成员。
? * 字典是一个无序、可变和有索引的集合。在 Python 中，字典用花括号编写，拥有键和值。
? * 创建并打印字典：
? *1. thisdict = {
? "brand": "Porsche",
? "model": "911",
? "year": 1963
? }
? print(thisdict)
? *2. k = [‘name‘,‘age‘,‘job‘]
? v = [‘zhagnsan‘,18,‘student‘]
? d = dict(zip(d,v))
? print(d)
? * 由键访问值
? 1. a[‘name‘]
? 2. a.get(‘name‘)
? * 列出所有键值对或键或值
? * a.items() #结果为所有的键值对
? * a.keys() #结果为所有键
? * a.values(） #结果为所有值
## 8. Python For 循环
? 1. 打印 fruits 列表中的每种水果：
? fruits = ["apple", "banana", "cherry"]
? for x in fruits:
? print(x)
? 2. 循环遍历单词 "banana" 中的字母
? for x in "banana":
? print(x)
? 3. 使用 range() 函数：
? for x in range(6):
? print(x)
? * 注：
? 1. range(6) 不是 0 到 6 的值，而是值 0 到 5。
? 2. range(2, 6)，这意味着值为 2 到 6（但不包括 6）
? 3. range() 函数默认将序列递增 1，但是可以通过添加第三个参数来指定增量值：range(2, 30, 3)
? 4. For 循环中的 Else：for 循环中的 else 关键字指定循环结束时要执行的代码块：
? * 实例
? for x in range(6):
? print(x)
? else:
? print("Finally finished!")
## 9. Python 函数：在 Python 中，使用 def 关键字定义函数
? 1. 定义
? * def my_function():
? print("Hello from a function"
? * def my_function(fname):
? print(fname + " Gates")
? * 默认参数 ：如果我们调用了不带参数的函数，则使用默认值(默认值参数要放在其他参数后面)
? def my_function(country = "China"):
? print("I am from " + country)
?
? my_function("India")
? my_function()
? * 可变参数
? 1. *param(一个星号)，将多个参数收集到一个元组对象中
? 2. **param(两个星号)，将多个参数收集到一个字典对象中
? 2. 使用
? my_function()
? 3. 特点
? * 函数定义不能为空，但是如果您出于某种原因写了无内容的函数定义，请使用 pass 语句来避免错误
? 4. eval函数
? * eval("print(‘123‘)") # 结果为 123
? 5. 装饰器（给已有函数添加新功能）
? * 实例
? [from functools import wraps] #[]为可不写内容，
? def wrapper(func): #装饰器函数，func是被装饰器函数
? [@wraps(func)]
? def inner(*args,**kwargs)
? "在被装饰的函数之前要做的事"
? ret = func(*args,**kwargs)
? "在被装饰的函数之后要做的事"
? return ret
? return inner
? @wrapper #语法糖 @装饰器函数名
? def func(a,b): #被装饰函数
? print("你好"，a,b)
? return "新年好"
? * @property 用于把调用方法时改为调用变量
? 6. 生成器
? 1. 把return换成yield，yield只用于生成器函数，后跟返回值（return后函数结束，yield之后函数不会结束）
? 2. ret = func() #是把ret设置成生成器
? 3. print(ret) #结果为 生成器类型
? 4. print(ret.__next__()) #结果是执行了func函数之后的值
? 7. isinstance(obj,cla)检查obj是否是类cla的对象
? 8. issubclass(sub,super)检查sub类是否是super类的派生类
? 9. 几个内置方法
? 1. __str__ 返回调用这个方法的对象的内存地址
? 2. __repr__
## 10. Python Lambda
? 1. 语法
? lambda 形参 : 表达式
? 2. 实例
? 1. 一个 lambda 函数，它把作为参数传入的数字加 10，然后打印结果：
? x = lambda a : a + 10
? print(x(5))
? 2. 一个 lambda 函数，它把参数 a 与参数 b 相乘并打印结果：
? x = lambda a, b : a * b
? print(x(5, 6))
## 11. Python 类和对象
? * 使用名为 x 的属性，创建一个名为 MyClass 的类：
? class MyClass:
? x = 5
? * 创建一个名为 p1 的对象，并打印 x 的值：
? p1 = MyClass()
? print(p1.x)
? * 实例
? class Person:
? def __init__(self, name, age):
? self.name = name
? self.age = age
?
? def myfunc(self):
? print("Hello my name is " + self.name)
?
? p1 = Person("Bill", 63)
? p1.myfunc()
? 提示：self 参数是对类的当前实例的引用，用于访问属于该类的变量。它不必被命名为 self，您可以随意调用它，但它必须是类中任意函数的首个参数。
? * 注：类定义不能为空，但是如果您处于某种原因写了无内容的类定义语句，请使用 pass 语句来避免错误。
? 1. 类方法 方法前加@classmethod
? 2. 静态方法 方法前加@staticmethod
? 3. 私有方法 def __方法名
? 4. 接口类
? from abc import abstractclassmethod,ABCMeta
? class Animal(metaclass=ABCMeta):
? @abstractclassmethod
? def eat(self):
? pass
## 12. 打开文件 w写 r读 最后调用close方法关闭文件
? 1. 一直读入文件
? def tail(filemane):
? file = open(filename,encoding=‘utf-8‘)
? while True:
? line = file.readline()
? if line.strip():
? yield line.strip()
? g = tail(‘file‘)
? for i in g:
? print(‘*****‘,i)
## 13. 模块
? * re模块 正则模块
? 1. findall #找到所有字符串
? 2. search #从前往后找到一个就返回
? ret = re.search(‘a‘,‘I am a good man‘)
? ret.group() #得到值
? 3. match
? * collections模块
? 1. namedtuple #可命名元组
? from collections import namedtuple
? Point = namedtuple(‘point‘,[‘x‘,‘y‘])
? p = Point(1,2)
? print(p.x)
? print(p.y)
? 2. deque #双端队列
? import queue #队列
? q = queue.Queue()
? q.put(10)
? q.put(5)
? print(q.get()) #结果为10
? print(q.qsize()) #队列长度为2
? form collections import deque #双端队列
? dq = deque([1,2])
? dq.append() #从后面放数据
? dq.appendleft() #从前面放数据
? dq.pop() #从后面取数据
? dq.popleft() #从前面取数据
? 3. time模块
? import time
? time.time()
? time.sleep()
? print(time.strftime("%Y-%m-%d %X")) #结果为格式化后的时间 年-月-日 时:分:秒
? struct_time = time.localtime()
? print(struct_time) #结果为可定义元组
? print(struct_time.tm_year) #结果为计算机当前年份
? * os模块是与操作系统交互的接口
? 1. os.getcwd() #获取当前工作目录，即当前python脚本工作的目录路径
? 2. os.chdir("dirname") #改变当前脚本工作目录，相当于shell下的cd
? 3. os.curdir #返回当前目录
? 4. os.pardir #获取当前目录的父目录字符串
? 5. os.mkdir("dirname") #生成单极目录
? 6. os.rmdir("dirname") #删除单级空目录
? 7. os.makedirs("dirname1/dirname2") #生成多级目录
? 8. os.removedir("dirname") #删除多级空目录
? 9. os.remove() #删除一个文件
? 10. os.listdir("dirname") #列出指定目录下的所有目录包括子目录和隐藏目录
? 11. os.rename("oldname","newname") #重命名文件/文件夹
? 12. os.path.abspath(path) #返回规范化的绝对路径
? 13. os.path.exists(path) #判断路径是否存在
? 14. os.path.getatime(path) #返回path所指向的文件或者目录的最后访问时间
? 15. os.path.getmtime(path) #返回path所指向的文件或者目录的最后修改时间
? * sys模块是与python解释器交互的接口
? 1. sys.argv #命令行参数list，第一个元素是程序本身路径（只能在终端执行）
? 2. sys.exit(n) #退出程序。正常退出时sys.exit(0)，错误退出时sys.exit(1)
? 3. sys.version #获取python解释程序的版本信息
? 4. sys.path #返回模块搜索路径
? 5. sys.platform #返回操作系统平台名称
## 14. 序列化模块
? 1. 从数据类型 ——> 字符串的过程 就是序列化
? 2. 从字符串 ——> 数据类型的过程 就是反序列化
? * json *****
? * pickle ****
? * shelve ***
? json:
? * 通用的序列化格式(优点)
? * 只有很少一部分数据类型能够通过json转化成字符串(缺点)
? pickle：
? * 所有的python中的数据类型都可以转化成字符串形式(优点)
? * pickle序列化的内容只有python能够理解(缺点)
? * 反序列化依赖python代码(缺点)
? shelve
? * 序列化句柄
? * 使用句柄直接操作，非常 方便
json dumps序列化方法 loads反序列化方法
? import json
? dic = {"k":"v"}
? str_d = json.dumps(dic)
? print(type(str_d),str_d) #序列化结果<class ‘str‘> {"k","v"}
## 15. 异常处理
? 1. try: ...... except 异常类型: ......(最后可跟一个 except Exception as e: ......) finally: ......
## 16. 反射
? 1. 把字符串当成变量名、函数名来使用
## 17. 常用模块
? 1. hashlib模块
? 2. configparser模块原文：https://www.cnblogs.com/yhking/p/14413545.html