python学习笔记全过程_Python学习笔记（一）

[TOC]

简介

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

TrueFalse

不为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内置符号