编程思维
模块化思维：确定模块接口，封装功能
规则化思维：把过程抽象为规则，使计算机自动执行
化繁为简： 将大功能变为小功能组合，分而治之
代码复用和函数递归
-
代码复用 （模块化设计）
代码资源化：程序代码是一种用来表达计算的”资源“
代码抽象化：使用函数等方法对代码赋予更高级别的定义
代码复用:同一份代码在需要时可以被重复使用，抽象化的结果
函数和对象是代码复用的两种主要形式：
函数：将代码命名在代码层面建立了初步抽象
对象：属性和方法，<a>.<b> and <a>.<b>() 在函数之上再次组织进行抽象 -
递归 （函数中调用函数本身的方式）
类似数学归纳法 递归的实现： 函数+分支语句 两个关键特征 链条： #当前 n 和 n-1 之间的关系 基例： #终止递归的条件 def fact(n): # n 的阶乘的函数 if n == 0: return 1 else: return n*fact(n-1) 实例：汉诺塔 count = 0 def hanoi (n,src,dst,mid) #n plate qunlity global count if n == 1 : #基例部分，终止递归的条件 print ("{}:{} ->{}".format(1,src,dst)) count += 1 else : #递归链条 hanoi(n-1,src,mid,dst) print("{}:{}->{}".format(n,src,dst)) count +=1 hanoi(n-1,mid,dst,src)
调用相关
#不会出现函数重名的问题
import <库名>
<库名>.<函数名>(<函数参数>)
#容易产生库中函数与自定义函数重名的问题
from <库名> import <函数名>
from <库名> import*
<函数名>(<函数参数>)
import <库名> as <库别名>
<库别名>.<函数名>(<函数参数>)
分支结构
#多分支条件之间的覆盖问题是重要问题
#程序运行正常，但不正确，要注意多分支
#分支结构是程序的重要框架，读程序先看分支
if <条件1>:
<语句快1>
elif <条件2>：
<语句快2>
else:
<语句块n>
操作符 ： < <= >= > == !=
保留字 ： and or not
异常处理
try :
<语句快1> # 正常执行
except <异常类型>: #可选，如果填写，则只会处理该类型的异常
<语句快2> #出现异常时执行
else ： #不出现异常时执行
<语句块3>
finally : #一定会执行
<语句块4>
循环语句
遍历循环
for <循环变量> in <遍历结构> : # <遍历结构> 包括字符串，列表，文件，元组，字典等等
<语句块>
for <变量> in range (N) ： # 计数循环 N 次
<被循环执行的语句>
for <变量> in range (M,N,K):
<被循环执行的语句>
for c in s : # 字符串遍历循环 s 是字符串，遍历字符串每个字符，产生循环
<语句块>
for item in ls : #列表遍历循环 ls 是一个列表，遍历其每个元素，产生循环
<语句快>
for line in fi : #文件遍历循环 fi 是一个文件标识符，遍历其每行，产生循环
<语句快>
range()函数
range(N) #产生0到N-1的整数序列，共N个
range(M,N) # 产生M到N-1的整数序列，例 range(2 , 5) 产生2，3，4整数序列
无限循环
while <条件> ： 反复执行语句块，知道条件不满足时，跳出循环
<语句块>
brake and continue
brake ：跳出循环结构
continue : 跳出当次循环，执行下一次循环
循环扩展
for i in s ；
<语句块1>
else ： #语句块1中有continue关键字或者正常执行时，都会执行else语句。但是如果语句1中执行了break语句，语句块2将不会执行。
<语句快2>
数据类型
-
整数类型
可正可负，没有取值范围限制 pow(x,y) 函数：计算 x**y 十进制 1234 二进制 0b101 八进制 0o437 十六进制 0x65 -
浮点数类型
浮点数间运算存在不确定尾数。 >>> 0.1+0.2 result ： 0.30000000000000004 >>> 0.1 + 0.2 == 0.3 result : False round(x,d) : 对x四舍五入，d是小数截取位数 # 浮点数间运算及比较用 round() 函数辅助 4.3e-3 值为 0.0043 9.6e5 值为 960000.0 -
复数类型 (only python have this type)
数值运算操作符
x + y x - y x*y x/y x//y (整数除) -x(负数) x%y (结果为余数) x**y (幂运算，y可以为小数) 类型间可以进行混合运算，结果为最宽的类型 3 + 4.0 = 7.0 数值运算函数 abs(x) 绝对值 abs(-10.01) result: 10.01 divmod(x,y) 商余(x//y , x%y) divmod(10 , 3) result : (3,1) pow(x,y[,Z]) 幂余(x**y)%z pow(3,pow(3,99),10000) result : 4587 # 不使用10000这个参数，计算量将非常大，普通计算机无法计算 round(x[,d]) 四舍五入 round(-10.123 , 2) result : -10.12 max(x1 ,x2 ,x3,...) 最大值 min(x1 ,x2 ,x3,...) 最小值 int(x) float(x)字符串类型及操作
表示方法有三种： 单引号'里面出现的双引号当做字符处理' 双引号"里面出现的单引号当做字符处理" 三引号 '''里面出现的单引号和双引号为字符的一种''' or """第四种方式""" 字符串序号：str = '0123456789:' [0~10] 或者 [-12 ~ -1] -
字符串的使用
使用 [] 获取字符串中一个或多个字符 索引：返回字符串中单个字符 <字符串>[M] 切片：返回字符串中一段字符子串 <字符串>[M : N] #[:N] 从开头 [M:] 到结尾 <字符串>[M:N:K] 根据步长K对字符串切片 >>>"012345678910"[2:8:2] result : '246' >>>"0123456789"[::-1] result : '9876543210' 转义符 \ : 表达特定字符的本意 形成一些组合，表达一些不可打印的含义 "\b" 回退 "\n" 换行（光标移动到下行首） "\r" 回车（光标移动到本行首） -
字符串的操作符
x + y 连接两个字符串 n * x 或 x * n 复制n次字符串x x in s 如果x是s的子串，返回 True ，否则返回 False -
字符串处理函数
len (x) 返回字符串x的长度 len("一二三四56") result ： 6 str (x) 任意类型x所对应的字符串形式 str(1.23) result : "1.23" str([1,2]) result : "[1,2]" hex(x) or oct(x)将十进制数转换成小写形式的字符串 hex(425) result : "0x1a9" oct(425) result : "0x651" Unicode编码，Python字符串的编码方式。（0~1114111 (0x10FFFF)）每个编码对应一个字符 chr(u) x 为 Unicode编码，返回其对应字符 ord(x) x为字符，返回其对应的Unicode编码 方法 str.lower() or str.uppper() str.split() str.count(sub) "a apple a day".count("a") result : 4 # 返回子串sub在str中出现的次数 str.replace(old , new) "python".repalce("a" , "123") result : "pytho123" str.center(width[,fillchar]) "python".center(20,"=") result : '=======python=======' str.strip(chars) "= =python= =".strip(" =np") result: "ytho" str.join(iter) ",".join("12345") result : '1,2,3,4,5' -
字符串类型的格式化
<模版字符串>.format(<逗号分割的参数>) "{}:计算机{}的CPU占用率为{}%".format("2020-3-14" , A , 10) format() 方法的格式控制 ：<填充> <对齐> <宽度> < , > < .精度 > <类型> #<对齐> ： < 左对齐 >右对齐 ^居中对齐 < , > 千位分隔符 >>> "{0:=^20}".format("python") result : '=======python=======' >>> "{0:*>20}".format("bit") result : '*****************bit' >>> "{:10}".format("BIT") result : 'BIT ' >>>"{0:,.2f}".format(12345.67889) result : '12,345.68' >>>"{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425) result : '110101001,Ʃ,425,651,1a9,1A9' # <类型> b 二进制 c unicode字符 d 十进制 o 八进制 x 小写十六进制 X 大写16进制 >>> "{0:e},{0:E},{0:f},{0:%}".format(314.15) result : '3.141500e+02,3.141500E+02,314.150000,31415.000000%' # <类型> e E f %
组合数据类型
-
集合类型：集合是多个元素的无序组合
集合类型与数学中的集合概念一致 元素之间无序且唯一，不存在相同元素 集合元素不可更改，不能是可变数据类型 如列表就不行 例 A = {"python", 123 ,(a,b,c,d)} #使用{}建立 B = set("pypy123") #使用set()建立 操作符 S | T 并 S - T 差 S & T 交 S ^ T 补 S <= T 或 S < T 返回 True / False 判断 S 和 T 的子集关系 S >= T 或 S > T 返回 True / False 判断 S 和 T 的包含关系 增强操作符 处理方法 S.add(x) S.discard(x) 移除元素x，如果集合中不存在x ， 不报错。 s.remove(x) 移除元素x，如果x不存在于集合中，产生KeyError异常 s.clear() 移除S中所有元素 s.pop() 随机返回S的一个元素，若S为空产生KeyError异常 s.copy() 返回集合S的一个副本 len(S) 返回集合S的元素个数 x in S x not in S set(x) 将其他类型变量x转变为集合类型 应用场景 最典型的使用，应用set()进行数据去重 -
序列类型：具有先后关系的一组元素
基础 包含 字符串""，元组() or null ，列表 [] #元组的元素创建后不可改变 通用操作符 x in s x not in s s + t s*n / n*s s[j] s[i:j:k] 通用函数和方法 len(s) min(s) max(s) s.index(x) / s.index(x,i,j) #第一次出现的位置 s.count(x) # 出现 x 的总次数 应用场景 最主要最用：表示一组有序数据，并操作它们 元素遍历 元组用于元素不改变的应用场景，更多用于固定搭配场景 数据保护 列表更加灵活，它是最常用的序列类型
函数
定义：是一段代码的表示
函数是一段具有特定功能的，可重用的语句组。可以重用。
def <函数名> (<必要参数>，<可选参数>) : # I 输入
<函数代码> # P 处理
return <返回值1> , <返回值2> # O 输出 返回多个返回值时，为元组类型
可变参数传递
def <函数名> (<参数> ，*b): #参数总数量不确定
局部变量和全局变量
基本数据类型，局部变量会在函数调用完，被计算机释放掉。
基本数据类型，函数内部使用全局变量，需要在函数体内声明 global s
组合数据类型，如果一个组合数据类型在函数中创建了，该变量为局部变量，如果函数内未创建而只是调用外部变量，则该变量无需声明默认为全局变量。
lambda函数
特定使用，非常规使用
<函数名> = lambda <参数> ： <表达式>
174
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
