一、概述
简史
- 1989：Guido van Rossum
- 2008：python3.0 诞生
- 2014：宣布2.7支持到2020
- 2017：AI元年，Python崛起
环境
anaconda + pycharm
Python3.6
二、变量类型
- 数字类型 Number
- 字符串类型 str
- 列表 list
- 元组 tuple
- 字典 Dictionary
- 集合 set
- 数字类型 Number
- 数字类型没有大小限制
- 整数
- 浮点数
- 复数 complex
- 布尔值(布尔值可以跟数字直接操作)
字符串类型 str
表示方法：
- 单引号
- 双引号
- 三引号（三个单引号或者三个双引号）
- 单双引号交错使用
- 格式化(利用百分号（%）) %d: 整数 %s: 字符串
利用format函数
s = "{}新手".format("Python")
None
表示什么都没有
如果函数没有返回值，可以返回 None
用来占位
三、内置数据结构
1.list(列表）
# 1, 创建空列表
l1 = []
# 2. 创建带值的列表
l2 = [100]
# 3. 创建列表，带多个值
l3 = [2,3,1,4,6,4,6]
# 4. 使用list()
l4 = list()
列表常用操作
访问
使用下标操作（索引）
列表的位置是从0开始
分片操作
对列表进行任意一段的截取
l[:]
注意截取的范围，包含左边的下标值，不包含右边的下标值
标值可以为空，如果不写，左边下标值默认为0， 右边下标值为最大数加一，即表示截取到最后一个数据
分片可以控制增长幅度，默认增长幅度为1
# 打印从下标1开始的数字，每次隔一个
print(l[1:6:2])
下标可以超出范围，超出后不在考虑多余下标内容
下标值，增长幅度可以为负数,为负数，表明顺序是从右往左,规定： 数组最后一个数字的下标是-1
分片操作是生成一个新的list
- del: 删除命令
- 使用加号链接两个列表
- 使用乘号操作列表(相当于把n个列表接在一起)
- 成员资格运算
- 链表的遍历
# for in list
a = [1,2,3,4,5]
# 挨个打印a里边的元素
for i in a:
print(i)
# range
# in 后面的变量要求是可以可迭代的内容
for i in range(1,10):
print(i)
# 双层列表循环
# a 为嵌套列表，或者叫双层列表
a = [["one", 1], ["two", 2], ["three", 3] ]
for k,v in a:
print(k, "--", v)
# 双层列表循环变异
# a 为嵌套列表，或者叫双层列表
a = [["one", 1, "eins"], ["two", 2,"zwei"], ["three", 3,"drei"] ]
# 这个例子说明，k，v,w的个数应该跟解包出来的变量个数一致
for k,v,w in a:
print(k, "--", v, "--",w)
- 列表内涵: list content
# for 创建
a = ['a', 'b', 'c']
# 用list a创建一个list b
# 下面代码的含义是，对于所有a中的元素，逐个放入新列表b中
b = [i for i in a]
# 对a中所有元素乘以10，生成一个新list
a = [1,2,3,4,5]
# 用list a创建一个list b
# 下面代码的含义是，对于所有a中的元素，逐个放入新列表b中
b = [i*10 for i in a]
# 还可以过滤原来list中的内容病放入新列表
# 比如原有列表a， 需要把所有a中的偶数生成新的列表b
a = [x for x in range(1,35)] #生成从1到34的一个列表
# 把a中所有偶数生成一个新的列表 b
b = [m for m in a if m % 2 == 0]
# 列表生成式可以嵌套
# 由两个列表a，b
a = [i for i in range(1,4)] # 生成list a
b = [i for i in range(100,400) if i % 100 == 0]
# 列表生成是可以嵌套,此时等于两个for循环嵌套
c = [ m+n for m in a for n in b]
# 上面代码跟下面代码等价
for m in a:
for n in b:
print(m+n, end=" ")
# 嵌套的列表生城市也可以用条件表达式
c = [ m+n for m in a for n in b if m+n < 250]
- 关于列表的常用函数
len:求列表长度
a = [x for x in range(1,100)]
print(len(a))
max:求列表中的最大值
b = ['man', 'film', 'python']
print(max(b))
min
list：将其他格式的数据转换成list
# 把range产生的内容转换成list
print(list(range(12, 19)))
append 插入一个内容, 在末尾追加
a = [ i for i in range(1,5)]
a.append(100)
insert: 制定位置插入
# insert(index, data), 插入位置是index前面
a.insert(3, 666)
del 删除
pop，从对位拿出一个元素，即把最后一个元素取出来
last_ele = a.pop()
remove:在列表中删除指定的值的元素(如果被删除的值没在list中，则报错)
clear:清空
reverse:翻转列表内容，原地翻转
a = [ 1,2,3,4,5]
a.reverse()
extend:扩展列表，两个列表，把一个直接拼接到后一个上
a = [ 1,2,3,4,5]
b = [6,7,8,9,10]
a.extend(b)
count:查找列表中指定值或元素的个数
a_len = a.count(8)
copy: 拷贝，此函数是浅拷贝
b = a.copy()
2.tuple(元组)
# 创建空元组
t = ()
# 创建一个只有一个值的元组
t = (1,)
t = 1,
# 创建多个值的元组
t = (1,2,3,4,5)
t = 1,2,3,4,5
# 使用其他结构创建
l = [1,2,3,4,5]
t = tuple(l)
元组的特性
- 是序列表，有序
- 元组数据值可以访问，不能修改
- 元组数据可以是任意类型
- list所有特性，除了可修改外，元组都具有
- 元组的函数
len: 获取元组的长度
max, min:最大最小值
count: 计算制定数据出现的次数
index:求制定元素在元组中的索引位置
3.set(集合)
# 集合的定义
s = set()
# 此时，大括号内一定要有值，否则定义出的是一个dict
s = {1,2,3,4,5,6,7}
# 如果只是用大括号定义，则定义的是一个dict类型
d = {}
集合的特征
- 集合内数据无序，即无法使用索引和分片
- 集合内部数据元素具有唯一性，可以用来排除重复数据
- 集合内的数据，str, int, float, tuple,冰冻集合等，即内部只能放置可哈希数据
- 集合序列操作
- 成员检测(in,not in)
- 遍历
# for 循环
s = {4,5,"i"}
for i in s:
print(i, end=" ")
# 带有元组的集合遍历
s = {(1,2,3), ("just", "for", "fun"), (4,5,6)}
for k,m,n in s:
print(k, "--", m, "--", n)
for k in s:
print(k)
- 集合的内涵
# 普通集合内涵
# 以下集合在初始化后自动过滤掉重复元素
s = {23,223,545,3,1,2,3,4,3,2,3,1,2,4,3}
# 普通集合内涵
ss = {i for i in s}
# 带条件的集合内涵
sss = {i for i in s if i % 2 == 0}
# 多循环的集合内涵
s1 = {1,2,3,4}
s2 = {"just", "for", "fun"}
s = {m*n for m in s2 for n in s1}
s = {m*n for m in s2 for n in s1 if n ==2}
- 集合函数
len, max, min
set:生成一个集合
add：向集合内添加元素
clear
copy
remove:移除制定的值，直接改变原有值，如果要删除的值不存在，报错
discard:移除集合中指定的值，跟 remove 一样，但是入股要删除的话，不报错
pop 随机移除一个元素
函数
- intersection: 交集
- difference:差集
- union: 并集
- issubset: 检查一个集合是否为另一个子集
- issuperset: 检查一个集合是否为另一个超集
数学操作 s1 = {1,2,3,4,5,6}
s2 = {5,6,7,8,9}
s_1 = s1 - s2
s_2 = s1 + s2
frozen set:冰冻集合
不可以进行任何修改的集合
# 创建
s = frozenset()
4.dict(字典)
没有顺序的组合数据，数据以键值对形式出现
# 字典的创建
# 创建空字典1
d = {}
# 创建空字典2
d = dict()
# 创建有值的字典， 每一组数据用冒号隔开， 每一对键值对用逗号隔开
d = {"one":1, "two":2, "three":3}
# 用dict创建有内容字典1
d = dict({"one":1, "two":2, "three":3})
# 用dict创建有内容字典2
# 利用关键字参数
d = dict(one=1, two=2, three=3)
#
d = dict( [("one",1), ("two",2), ("three",3)])
字典的特征
- 字典是序列类型，但是是无序序列，所以没有分片和索引
- 字典中的数据每个都有键值对组成，即kv对
- key: 必须是可哈希的值，比如int,string,float,tuple, 但是，list,set,dict 不行
- value: 任何值
字典常见操作
# 访问数据
d = {"one":1, "two":2, "three":3}
# 注意访问格式
# 中括号内是键值
print(d["one"])
d["one"] = "eins"
# 删除某个操作
# 使用del操作
del d["one"]
# 成员检测， in， not in
# 成员检测检测的是key内容
d = {"one":1, "two":2, "three":3}
if 2 in d:
print("value")
if "two" in d:
print("key")
if ("two",2) in d:
print("kv")
# 按key来使用for循环
d = {"one":1, "two":2, "three":3}
# 使用for循环，直接按key值访问
for k in d:
print(k, d[k])
# 上述代码可以改写成如下
for k in d.keys():
print(k, d[k])
# 只访问字典的值
for v in d.values():
print(v)
# 注意以下特殊用法
for k,v in d.items():
print(k,'--',v)
字典生成式
d = {"one":1, "two":2, "three":3}
# 常规字典生成式
dd = {k:v for k,v in d.items()}
# 加限制条件的字典生成式
dd = {k:v for k,v in d.items() if v % 2 == 0}
字典相关函数
len, max, min, dict
str(字典): 返回字典的字符串格式
clear: 清空字典
items: 返回字典的键值对组成的元组格式
keys:返回字典的键组成的一个结构
values: 同理，一个可迭代的结构
get: 根据制定键返回相应的值
d = {"one":1, "two":2, "three":3}
print(d.get("on333"))
# get默认值是None，可以设置
print(d.get("one", 100))
: 使用指定的序列作为键，使用一个值作为字典的所有的键的值
l = ["eins", "zwei", "drei"]
# 注意fromkeys两个参数的类型
# 注意fromkeys的调用主体
d = dict.fromkeys(l, "oops")
四、表达式
运算符
- 算数运算符
- 比较或者关系运算符
- 赋值运算符
- 逻辑运算符
- 位运算
- 成员运算
- 身份运算符
- 算数运算符
- 加 +
- 减 -
- 乘 *
- 除 /
- 取余 %
- 取商(地板除) //
- 幂运算 **
⚠️Python 没有自增自减运算符
比较运算符
比较的结果是布尔值（True/False）
赋值运算符
- =
- += （-=， ×=， /=, //=, %=, **=）
逻辑运算符
结果如果是0则为False， 否则为True
短路
Python 中没有异或运算
成员运算符
用来检测某一个变量是否是另一个变量的成员
身份运算符
- is: 用来检测两个变量是否是同一个变量
- is not: 两个变量不是同一个变量
运算符的优先级
括号具有最高优先级
** 指数 (最高优先级)
~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % // 乘，除，取模和取整除
+ - 加法减法
\>> << 右移，左移运算符
& 位 'AND'
^ | 位运算符
<= < > >= 比较运算符
<> == != 等于运算符
= %= /= //= -= += *= **= 赋值运算符
is is not 身份运算符
in not in 成员运算符
not or and 逻辑运算符
五、程序结构
顺序
分支
基本语法 # 表达式后面的冒号不能少
# 用缩进来表示同一个代码块
if 条件表达式：
语句1
语句2
语句3
..
双向分支 # if 和 else 一个层级，其余语句一个层级
if 条件表达式:
语句1
语句2
else:
语句1
语句2
多路分支 if 条件表达式：
语句1
.
elif 条件表达式：
语句1
elif 条件表达式：
语句1
..
else:
语句1
.
Python 没有 switch-case 语句
循环
for 循环
for 变量
in 序列：
语句1
语句2
range
生成一个数字序列
范围:
[m,n) # 打印 1～10
for i in range(1,11):
print(i)
for-else
当for循环结束的时候，会执行else语句
else语句可选
while 循环
while 条件表达式：
语句块
#另外一种表达方法
while 条件表达式：
语句块1
else：
语句块2
循环之break,continue,pass
break： 无条件结束整个循环，简称循环猝死
continue：无条件结束本次循环，从新进入下一轮循环
pass：表示略过，通常用于站位，没有跳过功能
六、函数
def关键字
代码缩进 # 定义
def func():
print("这是一个函数")
# 调用
func()
函数的参数和返回值
参数： 负责给函数传递一些必要的数据或者信息
- 形参（形式参数）： 在函数定义的时候用到的参数没有具体值，只是一个占位的符号，成为形参
- 实参（实际参数）： 在调用函数的时候输入的值
返回值： 函数的执行结果
- 使用 return 关键字
- 如果没有 return ，默认返回一个 None
- 函数一旦执行 return 语句，则无条件返回，即结束函数的执行
# return语句的基本使用
# 函数打完招呼后返回一句话
def hello(person):
print("{0}, 你肿么咧".format(person))
print("Sir, 你不理额额就走咧")
return "我已经跟{0}打招呼了，{1}不理我".format(person, person)
p = "明月"
rst = hello(p)
print(rst)
# 定义一个函数，打印一行九九乘法表
def printLine(row):
for col in range(1, row+1):
# print函数默认任务打印完毕后换行
print( row * col, end=" ")
print("")
# 九九乘法表
# version 2.0
for row in range(1,10):
printLine(row)
参数详解
- 参数分类
- 普通参数
- 默认参数
- 关键字参数
- 收集参数
- 普通参数
参见上例
定义的时候直接定义变量名
调用的时候直接把变量或者值放入指定位置
def 函数名（参数1， 参数2，
.):
函数体
# 调用
函数名（value1, value2,
.)
默认参数
形参带有默认值
调用的时候，如果没有对相应形参赋值，则使用默认值
def func_name(p1=v1, p2=v2
.):
func_block
#调用1
func_name()
# 调用2
value1 = 100
value2 = 200
func_name(value1,value2)
关键字参数
def func(p1=v1, p2=v2
..):
func_body
# 调用函数：
func(p1=value1, p2=value2
.)
收集参数
把没有位置，不能和定义时的参数位置相对应的参数，放入一个特定的数据结构中
def func(*args):
func_body
# 按照list使用方式访问args得到传入的参数
# 调用：
func(p1, p2, p3,
..)
收集参数混合调用的顺序问题
收集参数，关键字参数，普通参数可以混合使用
使用规则就是，普通参数和关键字参数优先
定义的时候一般找普通参数，关键字参数，收集参数 tuple，收集参数 dict
返回值
函数和过程的区别
- 有无返回值
- 需要用return显示返回内容，
- 如果没有返回，则默认返回None
递归函数
python对递归深度有限制，超过限制报错
# 斐波那契额数列
# 一列数字，第一个值是1， 第二个也是1， 从第三个开始，每一个数字的值等于前两个数字出现的值的和
# 数学公式为： f(1) = 1, f(2) = 1, f(n) = f(n-1) + f(n-2)
# 例如： 1,1，2，3,5,8,13.。。。。。。。。
# n表示求第n个数子的斐波那契数列的值
def fib(n):
if n == 1:
return 1
if n == 2:
return 1
return fib(n-1) + fib(n-2)
print(fib(3))
print(fib(10))
汉诺塔问题
规则：
每次移动一个盘子
任何时候大盘子在下面，小盘子在上面
方法：
n=1： 直接把A上的一个盘子移动到C上， A->C
n=2:
把小盘子从A放到B上， A->B
把大盘子从A放到C上， A->C
把小盘子从B放到C上， B->C
n=3:
把A上的两个盘子，通过C移动到B上去， 调用递归实现
把A上剩下的一个最大盘子移动到C上， A->C
把B上两个盘子，借助于A，挪到C上去， 调用递归
n = n：
把A上的n-1个盘子，借助于C，移动到B上去，调用递归
把A上的最大盘子，也是唯一一个，移动到C上，A->C
把B上n-1个盘子，借助于A，移动到C上， 调用递归
def hano(n, a, b, c):
'''
汉诺塔的递归实现
n：代表几个盘子
a：代表第一个塔，开始的塔
b：代表第二个塔，中间过渡的塔
c：代表第三个塔, 目标塔
'''
if n == 1:
print(a, "-->", c)
return None
'''
if n == 2:
print(a, "-->", b)
print(a, "-->", c)
print(b, "-->", c)
return None
'''
# 把n-1个盘子，从a塔借助于c塔，挪到b塔上去
hano(n-1, a, c, b)
print(a, "-->", c)
# 把n-1个盘子，从b塔，借助于a塔，挪到c塔上去
hano(n-1,b, a, c)
a = "A"
b = "B"
c = "C"
n = 1
hano(n, a, b, c)
n = 2
hano(n, a, b, c)
n = 3
hano(n, a, b, c)
查找函数帮助文档
用 help 函数
help(print)
使用
__doc__ def stu(name, age):
'''
这是文档的文字内容
:param name: 表示学生的姓名
:param age: 表示学生的年龄
:return: 此函数没有返回值
'''
pass
print(help(stu))
print("*" * 20)
print(stu.__doc__)
七、变量作用域
分类：按照作用域分类
- 全局(global): 在函数外部定义
- 局部（local)：在函数内部定义
LEGB原则
- L（Local）局部作用域
- E（Enclosing function locale）外部嵌套函数作用域
- G（Global module）函数定义所在模块作用域
- B（Buildin）： python内置魔抗的作用域
提升局部变量为全局变量(使用global)
def fun():
global b1
b1 = 100
print(b1)
print("I am in fun")
# b2的作用范围是fun
b2 = 99
print(b2)
fun()
print(b1)
globals, locals函数
可以通过globals和locals显示出局部变量和全局变量
# globals 和 locals
# globals 和 locals 叫做内建函数
a = 1
b = 2
def fun(c,d):
e = 111
print("Locals={0}".format(locals()))
print("Globals={0}".format(globals()))
fun(100, 200)
eval()函数
把一个字符串当成一个表达式来执行， 返回表达式执行后的结果
eval(string_code, globals=None, locals=None)
exec()函数
跟eval功能类似， 但是，不返回结果
exec(string_code, globals=None, locals=None)
posted on 2018-06-03 19:24
Ying-er 阅读(816)
评论(0) 编辑 收藏 所属分类:
Python 、
喵