Python学习笔记（一）
简介
Python是一种解释型、面向对象、动态数据类型的程序设计语言
Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。
- 解释型语言： 这意味着开发过程中没有编译这个环节。类似于PHP和Perl语言。
- 交互式语言： 这意味着，您可以在一个 Python 提示符 >>> 后直接执行代码。
- 面向对象语言: 这意味着Python支持面向对象的风格或代码封装在对象的编程技术。
——————————————————————————————————————————
Python 特点
1.易于学习：Python有相对较少的关键字，结构简单，和一个明确定义的语法，学习起来更加简单。
2.易于阅读：Python代码定义的更清晰，伪代码本质。
3.易于维护：Python的成功在于它的源代码（开源免费）是相当容易维护的。
4.一个广泛的标准库：Python的最大的优势之一是丰富的库，跨平台的，在UNIX，Windows和Macintosh兼容很好。
5.互动模式：互动模式的支持，您可以从终端输入执行代码并获得结果的语言，互动的测试和调试代码片断。
6.可移植：基于其开放源代码的特性，Python已经被移植（也就是使其工作）到许多平台。
7.可扩展：如果你需要一段运行很快的关键代码，或者是想要编写一些不愿开放的算法，你可以使用C或C++完成那部分程序，然后从你的Python程序中调用。
8.数据库：Python提供所有主要的商业数据库的接口。
9.GUI编程：即用户图形界面，Python支持GUI可以创建和移植到许多系统调用。
10.可嵌入: 你可以将Python嵌入到C/C++程序，让你的程序的用户获得"脚本化"的能力。
———————————————————————————————————————————
一、环境搭建
- 使用Anaconda3的jupyter notebook进行开发，官网下载，安装配置环境，打开cmd或prompt，输入jupyter notebook。
注：IE浏览器进入WebUI需要token，token只有通过prompt命令行启动时才有——其他浏览器不需要
anaconda-navigator #导航视窗
jupyter notebook #开发本本
- 默认的工作空间是用户目录，现在进行修改
#生成jupyter的配置文件
jupyter notebook --generate-config
#打开生成的jupyter_notebook_config.py,配置工作空间位置
c.NotebookApp.notebook_dir = 'D:\JupyterProject'
- 确保中文不乱码
# coding=utf-8 指定编码支持中文，3.x无需
工程结构：
-
Python工程结构
-
模块（module）
-
一个Python文件就是一个模块
- .py source code
- .pyc compiled bytecode
- .pyo optimized bytecode
-
-
包（package）
-
包含多个Python文件
- __init__.py ——必须要由，不然就是一个普通目录而不是py包
-
部分导入
- from xx import path
二、一般特性
!!!编程规范：PEP8
变量：
- _或字母开头，_ 、字母和数字组成
- 弱类型，类型不是必须指定、类型不固定
- 大小写敏感
- 不能使用关键字
import keyword
keyword.kwlist #查看关键字列表
注释：
- 单行注释：#号
- 多行注释：三个单或双引号 ,字符串赋值。也可做为注释
内置函数：
- type() :返回对象类型
- dir() :函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表
- input()/print() : 输入/打印 输出
- id() :返回对象的地址 ，一般用来判断两个变量是否引用了同一个值
———————————————————————————————————————————
三、数据类型
1、数值类型
a）数值类型：int 、float、complex复数
- int型式没有大数限制的
- 可以用下划线来标记位数，但是在小数点前后不能使用_
b）操作符
| 操作符 | 说明 | 操作符 | 说明 |
|---|---|---|---|
| x + y | 加法 | int(x) | 转换成整数 |
| x - y | 减法 | float(x) | 转换成浮点数 |
| x * y | 乘法 | complex(re, im) | 创建一个复数 |
| x / y | 除法 | c.conjugate() | 返回复数的共轭复数 |
| x // y | 除后取整 | divmod(x, y) | 返回一个包含商和余数的元组 |
| x % y | 除后取余 | pow(x, y) | 返回x的y次方 |
| -x | 负数 | x y** | 返回x的y次方 |
| abs(x) | 取绝对值 | round(x[, n]) | 方法返回浮点数x的四舍五入值 |
序列Seq
2、列表 list[]
a）特点
- 有序，可使用位置索引
- 表长度和元素都是可变的
- 可储存不同类型的数据
b）使用
- 创建：['one', 2, [3, 4], (5, 6)]
- 获取：两套下标，从0起始，从左往右下标为正，从右往左下标为负
- 判断：in 和 not in
——————————————————————————————————————————
3、元组
a）特点
-
有序
-
长度和元素都不可变，安全级别较高的场景应用
- (元素的引用地址不能变，但地址内的值可变)
-
可以存储不同类型
b）使用
- 创建 ： (1,”box",3.62) 、1,”box",3.62、tuple([1,”box",3.62])
- 获取：两套下标,x[0], x[2], x[-1], x[-3]
- 判断：in 和 not in
———————————————————————————————————————————
4、列表&元组的操作
a）切片
-
通过切片获得子集
-
[start : end : step]
- start:起始索引，从0开始，-1表示结束，缺省则为0
- end：结束索引，不被包括，缺省则为长度，
- step：步长，end-start，步长为正时，从左向右取值。步长为负时，反向取值。缺省为1
-
-
正向取偶数下标子集：x[0::2]、x[::2]
-
反向取间隔下标子集：x[-1:0:-2]
b）遍历
#使用缩进代表子代码块
for x in list:
print(x)
c）混合
将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象
//zip 拉链
matrix = [[1, 2, 3, 4],[5, 6, 7, 8],[9, 10, 11]]
//最短原则
list(zip(*matrix)) # result: [（1, 5, 9）, （2, 6, 10）, （3, 7, 11）]
//元组补空
t = (1,2,3,4)
list(zip(t))
———————————————————————————————————————————
5、range类型
a）特性
- 一段不可变的数字序列
- 经常被用作for里面来指定循环次数
b）使用
-
创建：range(start, stop, step)
- start 起始值，默认为0
- stop 终止值，不包括在内
- step 步长，默认为1，可为负，从右往左
-
切片：
x[1:-1:1]，中括号[]代替小括号，语法规则同创建。 -
遍历：
for v in range(0,10,1):print(v)
———————————————————————————————————————————
6、列表、元组、range转换
- 列表元组可以互转：
tuple(lst) | list(tup) - range到列表元组：
list(r) | tuple(r)
———————————————————————————————————————————
7、pack & unpack
a）pack ——打包
-
变量转序列
t=1，2，3 #t=(1,2,3) s='x','y','z' #s=('x','y','z')
b）unpack ——解包
-
序列转变量
a,b,c=t #a=1,b=2,c=3 -
使用*号代表出现0次或多次
a,*b=t #a=1,b=[2,3] #超长时 *a,c,d,e=t #t中只有三个元素，因此a=[] -
swap交换:
a，b=b,a
8、常见序列操作
- 数据：s = [1,2,3] t = [4,5,6] n = 2
| 操作符 | 说明 |
|---|---|
| s+t | 拼接：[1,2,3,4,5,6] |
| s * n or n * s | 乘法：[1,2,3,1,2,3] ，重复序列 |
| len(s) | 计算序列的长度3 |
| min(s) | 获得序列中的最小值：1 |
| max(s) | 获得序列中的最大值：1 |
| s.index(x[, i[, j]]) | 获得第1个x元素的索引 (索引值在i和j之间)，指定范围内搜索元素值的下标 |
| s.count(x) | 序列x元素出现的次数 |
- 可变序列支持的操作(List) ——元组和range都不支持
| 操作符 | 说明 |
|---|---|
| s[i] = x | 更新指定索引的值 |
| s[i:j] = t | 使用序列t替换s中的i到j的值 |
| del s[i:j] | 等同于s[i:j] = [] |
| s[i:j:k] = t | 使用序列t中的值替换s[i:j:k]的值 |
| del s[i:j:k] | 删除s[i:j:k]的值 |
| s.append(x) | 将值x添加到序列的末尾 |
| s.clear() | 清空序列，相当于del s[:] |
| s.copy() | 创建一个s的浅拷贝 |
| s.extend(t) | 使用序列t扩展序列s |
| s.insert(i, x) | 在序列s的i索引处插入值x |
| s.pop(i) | 返回序列s中索引为i的值，并将该值从序列中移除 |
| s.remove(x) | 将序列中<第一个>值为x的元素移除 |
| s.reverse() | 将序列s倒序排列 |
9、集合 Set
a）特性
- 数据唯一不重复
- 无序，没有索引下标
b）创建 :
空集合 s=set()
非空集合 s={1,2,3,4,5}
c）操作：
并集：s1|s2|s3
交集：s1&s2&s3
差集：s1-s2-s3
对等差分 ：s1^s2^s3 并集减交集
d）判断
超集：issupperset()
子集：issubset()
相交: isdisjoint()
10、字典（Dict）
性质类似于Map映射
a）特性
- 通过键值对（key-value）来储存数据
- 储存的数据是无序的，可使用键索引
- 键是必须唯一，但值可以不唯一
- 键的类型只能是字符串、数字或元组，值可以是任何
b）创建
#空Dict
empty_dict = {}
#键值对
dict_1 = {1:'one', 2:'two', 3:'three'}
#构造函数
dict_2 = dict(one=1, two=2, three=3)
c）获取
x=d[1]
x=d['one']
x=d.get(1,"缺省值") #当get的key值不存在时，返回缺省值
d）遍历
#遍历字典的键
for k in x: #默认是Dict的键值集合，x.keys()
print(k)
#遍历字典的值
for v in x.values():
print(v)
#遍历字典的键和值
for k,v in x.items():
print(k,v)
11、字符串
a ）定义 ：
单引号 双引号 三引号（允许字符串换行）
#单引号
str1 = 'allows embedded "double" quotes'
#双引号
str2 = "allows embedded 'single' quotes"
#三引号
str3= '''Three single quotes,
span multiple lines'''
str4="""Three double quotes,
span multiple lines"""
b）操作
| 字符串操作 | 说明 | 举例 |
|---|---|---|
| string[n:m] | 字符串切片 | string='Hello World\n' string[0] string[:-1] string[3:5] |
| int() | 字符串转数值类型 | int("123") float("123") |
| str() | 数值类型转字符串 | str(123)str(123.456) |
| ord() | 字符转Unicode码 | ord('A') |
| chr() | Unicode码转字符 | chr(65) |
| lower() | 转成小写字符串 | "WELCOME".lower() |
| upper() | 转成大写字符串 | "welcome".upper() |
| split() | 分割字符串 | N'] words = "WELCOME TO PYTHON".split(' TO ') print(words)# ['WELCOME', 'PYTHON'] |
|---|---|---|
| join() | 将序列中的元素以指定的字符连接生成一个新的字符串 | s = '++' list=['1', '2', '3'] s.join(list) #result is '1++2++3' s.join('why') #result is 'w++h++y' |
| strip()lstrip()rstrip() | 用于移除字符串头尾/头/尾指定的字符（默认为空格或换行符）或字符序列 | s = ' "hi\\ \n\tPython" ' s.strip()# result is '"hi\ \n\tPython"' s.strip(' "no') # result is 'hi\ \n\tPyth' |
| in | 判断是否为子串 | 'or' in 'toronto or orlando' # True |
|---|---|---|
| find() | 返回子串开始的索引值，找不到子串时返回-1 | s = 'toronto or orlando's.find('or') # return index 1 s.find('or', 2, 8) # return -1, meaning not found |
| index() | 返回子串开始的索引值，找不到子串时抛出异常 | s = 'toronto or orlando's.index('or') # return index 1 s.index('or', 2, 8) # throw ValueError: substring not found |
| count() | 统计字符串里某个字符出现的次数 | s = 'toronto or orlando' s.count('or') # return 3 s.count('or', 2) # return 2 s.count('or', 2, 9) # return 0 |
| replace() | 方法把字符串中的 旧字符串替换成新字符串 | s = 'toronto or orlando's.replace('or', '/x\')# result: t/x\onto /x\ /x\lando s.replace('or', '/x\', 2)# result: t/x\onto /x\ orlando |
| startswith() | 检查字符串是否是以指定子字符串开头 | s = 'toronto or orlando' s.startswith('or') # return False s.startswith('or', 1) # return True s.startswith(('or', 'tor')) # return True |
|---|---|---|
| endswith() | 检查字符串是否是以指定子字符串结尾 | s = 'toronto or orlando' s.endswith('and') # return False s.endswith('and', 1, -1) # return True s.endswith(('and', 'do')) # return True |
| maketrans() translate() | 字符串转换，maketrans() 设置转换模式，一一替换，translate()执行转换操作。可以一次定义多个模式 | s = 'toronto or orlando' # define a translation table: table=s.maketrans('on', '.N') # o change to . # n change to N # translate using above table s.translate(table) # result: 't.r.Nt. .r .rlaNd.' |
12、布尔值与空值
空值： None ，特殊常量，表示空值，注意大小写
布尔值：True or False
- 有多种表示形式，只有字典和集合时以空集为True
| True | False |
|---|---|
| 不为0的数值 | 0, 0.0, 0+0j |
| 非空字符串 | 空字符串 |
| 非空列表 | 空列表 |
| 空字典 | 非空字典 |
| 空集合 | 非空集合 |
| - | None |
布尔操作：or 、and、not
13、比较操作符
| 操作符 | 解释 |
|---|---|
| < | 小于 |
| <= | 小于等于 |
| > | 大于 |
| >= | 大于等于 |
| == | 等于 |
| != | 不等于 |
| is | 判断两个标识符是不是引用自一个对象 |
| is not | 判断两个标识符是不是引用自不同对象 |
14、流程控制语句
- 条件选择语句 if
if guess > secret :
print("too large")
elif guess < secret : # elif is optional
print("too small")
else : # else is optional
print("equals")
-
循环语句
- Python中循环也有else语句，当循环条件不再满足时即循环结束时执行
while guessed != secret :
guessed = int(input("Guess a number: "))
else : # else is optional
print("Congratulation!")
for i in range(0, 8, 2) :
print(i)
else : # else is optional
print("Done!")
-
break\continue\pass
- break 将跳出循环语句，else也不会被执行
- continue，同
- pass ，占位语句，啥也不干
-
三元表达式： val1 if bool else val2 ,bool为真时返回val1，为假时返回val2
15、列表生成式 （重点）
- 列表生成式 ： 输出表达式 循环条件 判断语句
[x**2 for x in range(10) ] #1~10的数平方列表
[x for x in range(2,100) if x % 2 == 0] #2~100的偶数列表
from math import pi
[str(round(pi, i)) for i in range(1, 10)] #Π的位数梯级表
[[1 if r==c or r+c==3 else 0 for c in range(4)]for r in range(4)] #矩阵列表
sentence = 'what is this'
{ c for c in sentence if c != ' ' } #生成集合
sentence = 'what is this'
(w for w in sentence.split() if 'i' in w) #生成生成器
sentence = 'what is this'
{ w:{c for c in w if c not in 'aeiou'} for w in sentence.split() } #生成字典
16、enumerate函数
将可遍历的有序对象（列表，元组，字符串）组合为一个有索引号的序列，同时返回下标和数据
for i, v in enumerate('ABCDEFG') :
print(i, v)
四、变量作用域
1、全局变量：
- 定义在模块中的变量，全局变量在整个模块中可见
- globals()函数：返回所有定义在改模块中的全局变量
- 修改全局变量时，要先使用global关键字声明变量
msg = 'created in module'
def outer() :
def inner() :
global msg
msg = 'changed in inner'
inner()
outer()
print(msg)
2、局部变量
-
定义在函数中的变量
-
局部变量仅在定义的函数中中可见
-
locals()函数：返回所有定义在函数中的局部变量
-
自由变量：在函数中使用，但未定义在该函数中的非全局变量。
- 自由变量：修改时要先使用nonlocal关键字声明变量
def outer_1() :
msg = 'created in outer'
def inner() :
print(msg) # msg is a Free variable
inner()
outer_1()
3、作用域规则LEGB
- 使用 LEGB 的顺序来查找一个符号对应的对象
- Local -> Enclosed -> Global -> Built-in
- Local：一个函数或者类方法内部
- Enclosed：嵌套函数内
- Global：模块层级
- Built-in：Python内置符号
