Pythonfdu学习

本文是笔者根据fdu的python课程ppt总结的知识点，权当python基本知识的备忘录。第一次整理难免有很多疏漏与不足之处，希望能与大家多多交流、共同进步。

转义字符

isinstance(object,class)
用来判断object是否是指定类型：isinstance(3,int)

标识符对大小写敏感

整数可以为任意大的数值

c.real 返回实部
c.imag 返回虚部
c.conjuate 返回共轭复数

整除 // 浮点除法/ 取余%

数学函数

比较运算符： 返回bool值
内置数学函数：

import math 或者 from math import *

sin（） cos（）默认是弧度值

字符串

字符串转义

Range

range([start,]stop[,stop])
第一个参数表示起始值–（-1/0）
第二个参数表示终止值
第三个参数表示步长（默认为 1）

列表

用list表征-------- eg： list(range(10))
del 删除列表操作： del a_list

列表元素的增加：
可以使用 + 运算符来实现将元素增加到列表中的功能——actually 创建一个新列表
例： a_list = [3,4,5]
a_list = [3,4,5] + [7]

append()
alist.append(9) ——在列表的尾部添加元素

extend() -------在列表尾部添加多个元素
a = [5,2,4]
a.extend([7,8,9])
a>>> [5,2,4,7,8,9]

insert() ——将元素添加至列表的指定位置

用数乘的方式复制列表：


列表元素的删除：（删除特定位置的元素）

利用for循环删除列表中元素的重复

循环+remove ：remove() 删除首次出现的指定元素
x = [1,2,1,2,1,2,1,2,1]
for i in x:
if i == 1:
x.remove(i)
————然而代码逻辑是错误的

所以合乎逻辑的代码：

x = [1,2,1,2,1,1,1]
for i in x[::]
if i == 1
x.remove(i)

切片操作返回是和被切片对象相同类型对象的副本————当步长省略时可以顺便省略最后一个冒号

通常一个切片操作要提供三个参数 [start_index: stop_index: step]

start_index是切片的起始位置

stop_index是切片的结束位置（不包括）

step可以不提供，默认值是1，步长值不能为0，不然会报错ValueError。

当 step 是正数时，以list[start_index]元素位置开始， step做为步长到list[stop_index]元素位置（不包括）为止，从左向右截取，

start_index和stop_index不论是正数还是负数索引还是混用都可以，但是要保证 list[stop_index]元素的【逻辑】位置

必须在list[start_index]元素的【逻辑】位置右边，否则取不出元素。

比如下面的几个例子都是合法的：

alist = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

alist[1:5]

[1, 2, 3, 4]

alist[1:-1]

[1, 2, 3, 4, 5, 6, 7, 8]

alist[-8:6]

[2, 3, 4, 5]

当 step 是负数时，以list[start_index]元素位置开始， step做为步长到list[stop_index]元素位置（不包括）为止，从右向左截取，

start_index和stop_index不论是正数还是负数索引还是混用都可以，但是要保证 list[stop_index]元素的【逻辑】位置

必须在list[start_index]元素的【逻辑】位置左边，否则取不出元素。

比如下面的几个例子都是合法的：

alist = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

alist[-1: -5: -1]

[9, 8, 7, 6]

alist[9: 5: -1]

[9, 8, 7, 6]

alist[-1:1:-1]

[9, 8, 7, 6, 5, 4, 3, 2]

alist[6:-8:-1]

[6, 5, 4, 3]

成员资格判断： 常在循环中使用关键字in对可迭代对象的元素进行遍历

切片操作：

切片返回的是列表元素的浅拷贝

aList = [3, 5, 7]
bList = aList[::] #浅复制
aList == bList
True

aList is bList
False

id(aList) == id(bList)
False >>> bList[1] = 8

bList
[3, 8, 7]

aList
[3, 5, 7]

使用切片来原地修改列表内容

使用del与切片结合来删除列表元素：

alist = [3,5,7,9,11]
del alist[:3] #从第零个元素开始，到第二个元素，全部删掉
alist>>> [9,11]

列表排序：

sort
引用random库

**使用内置函数sorted对列表进行排序并返回新列表：

aList
[9, 7, 6, 5, 4, 3, 17, 15, 13, 11]

sorted(aList)
[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]

sorted(aList,reverse = True) #由大到小排列
[17, 15, 13, 11, 9, 7, 6, 5, 4, 3]
使用内置函数reversed方法对列表元素进行逆序排列并返回迭代对象**

reverse = True

序列大小比较：

sum对非数值型列表运算则出错

alist = [1,2,3]
blist = [4,5,6]
clist = zip(alist,blist)

list(clist)
[(1,4),(2,5),(3,6)]

enumberate

格式字符

%s 字符串采用str()的显示 %x 十六进制整数
%r 字符串(repr())的显示 %e 指数（基底写e）
%c 单个字符 %E 指数（基底写E）
%b 二进制整数 %f,%F 浮点数
%d 十进制整数 %g 指数(e)或浮点数(根据显示长度)
%i 十进制整数 %G 指数(E)或浮点数(根据显示长度)
%o 八进制整数 %% 字符%

字符串格式化
format_string%obj

x**y 幂运算
x==y x!=y 相等不等比较
x or y 逻辑或
x and y 逻辑与
not x 逻辑非

random函数库

基本输入输出
input（prompt） 首先promp 等待用户输入 直到用户按回车结束 返回用户输入的字符串
print（）

import 模块名 as 别名

Python代码编写规范–利用代码块的缩进来体现代码之间的逻辑关系
建议以四个空格为基本缩进单位，不建议采用tab来缩进
运算符两侧建议用空格分开 逗号在其后面添加一个空格 不同功能的代码块之间、不同的函数定义之间建议增加一个空行以提高可读性

每个import直到如一个模块

import math 
x = input('输入两边长及夹角(度)，以逗号分隔：') 
a, b, sita = eval(x) #序列解包 
c = math.sqrt(a**2 + b**2 - 2*a*b*math.cos(sita*math.pi/180)) 
print('c=', c)

---

id() 函数返回对象的唯一标识符，标识符是一个整数。 CPython 中 id() 函数用于获取对象的内存地址。

Python序列

列表 元祖 字典 字符串 集合 range 等等
列表 其中数据类型可以各不相同
[10,‘20’,‘thirty’,40.00]
通过下标来访问元素

列表元素修改

元组：

属于不可变序列

元素放在（）中

如果创建只有一个元素的元组，需要在元素后面加上一个括号: a_tuple = (‘a’,)

使用del删除元组对象 不能删除元组元素

元组中的元素不可变 但当元素所指向的对象可变 则该对象的值是可变的

选择与循环：

条件表达式：

算术关系符：
关系运算符：
测试运算符： in not in is is not
逻辑运算符：and or not
位运算符: ~ & | ^ << >>

比较特殊的运算符和逻辑运算符 and or 具有短路求值特点 只计算必须计算表达式的值
注意= 和 ==的区别

选择结构： 单分支 双分支 多分支 嵌套分支

双分支结构： value1 if condition else value2

利用多分支选择结构将成绩从百分制变换到等级制的用法:

选择结构的嵌套：注意缩进一致

循环结构：

for循环 while循环

while 表达式：
循环体
else：
else 字句

for 变量 in 序列或迭代对象：
循环体
else：
else子句

while not (,条件)


break 和 continue

循环嵌套

两维列表与循环嵌套

两维列表

循环嵌套的break

字符串与正则表达式：

字符串：

python字符串的驻留机制：——将其赋值给多个不同的对象时 内存中只有一个副本 多个对象共享该副本

判断s是否是字符串： isinstance(s, str)

import string

import string
s = input("请任意输入： ")
charset = string.ascii_letters + string.digits (将字母、数字构成一个集合)
t = “”
for x in s:
if x in charset:
t = t + x
print(t)

字符串转换函数：

str.lower()

• lower() • 得到小写格式字符串
• upper() • 得到大写格式字符串
• capitalize() • 得到首字母大写格式
• title() • 得到每个单词首字母大写格式
• swapcase() • 得到大小写互换格式

字符与asc_ii的互相转换函数：
ord（‘h’） ord(‘5’) -------- 将字符转换为asc_ii
chr(55)----‘7’ --------将asc_ii码转换为字符

字符串联接join（）

print(" ".join(input("请输入一串字符： "))) #输入一个字符串 输出以空格间隔的字符序列

获取字符串表达式的值：eval（.）
将数字转换成字符串 str(.)

简单的加密与解密——可以理解成：报数出圈

**** pop函数

字符串对齐的方法：
center(.) ljust(.) rjust(.)

打印三角形图案：
常用函数：
join eval()

记得对字符串进行这类类运算操作

字符串格式化：

Python字符串格式化之format()方法：

基本格式： <模板字符串>.format(<逗号分隔的参数>)

调用format（）方法后会***返回一个新的字符串***，同时参数从0开始编号：

从0编号举例：

a = 3
b = 4
print('a={1},b={0}'.format(a,b))

输出：a=4,b=3

a = 3
b = 4
print('a={0},b={1}'.format(a,b))

输出: a=3,b=4

用大括号

s = input('输入你在干啥： ')
print('肖炳楠在{}'.format(s))

“{}：计算机{}的CPU 占用率为{}%。”.format(“2016-12-31”,“PYTHON”,10)
Out[10]: ‘2016-12-31：计算机PYTHON的CPU 占用率为10%。’

format（）方法连接不同类型的变量与内容

print('the number {0:,} in hex is: {0:#x},the number {1} in oct is {1:#o}'.format(5555,55))

{0:,}中的逗号 使得输出三位一个逗号隔开–只能对十进制采用此操作

对数组、列表进行输出：


字符串分割：
字符串替换：

正则表达式：

1.普通字符：包括ascii字符 unicode字符 转义字符

python中 re模块提供正则表达式操作所需要的功能
re.finall(pattern,string) 以列表形式列出字符串中模式的所有匹配项
即使用时：
import re
re.findall(‘d’,‘goddness’)

2.正则表达式元字符： 字符类 预定义字符类 边界匹配符 重复限定符 分组符 选择符

（1）字符类：

函数设计与使用：

（一）函数定义与调用

定义格式：

def 函数名（[形参列表]）： #注意冒号
“注释”
函数体

函数调用：
函数名（[实参列表]）

在定义函数时，开头部分要写上注释，后调用函数时 输入左侧圆括号后 立即就会得到该函数的使用说明

函数可以返回值 也可以不返回 如果函数体中包含return语句 则返回值 否则不返回 即返回值为空

（二）形参与实参
多个形参 用逗号进行分隔
• 绝大多数情况下，在函数内部直接修改形参的值不会影响实参
• 在有些情况下，可以通过特殊的方式在函数内部修改实参的值

即：如果传递给函数的是Python可变序列，并且在函数内部使用下标或其他方式为可变序列增加、删除元素或修改元素值时，可以使得实参得到相应的修改。

（三） 参数类型：
普通参数 默认值参数 关键参数 可变长度参数等，
在定义函数时 不需指定参数的类型

Python函数的定义非常灵活，在定义函数时不需要指定参数的类型
，形参的类型完全由调用者传递的实参类型以及Python解释器的理解和推断来决定，类似于重载和泛型；
• 函数编写如果有问题，只有在调用时
才能被发现，传递某些参数时执行正确，而传递另一些类型的参数时则出现错误。

（1）默认值参数：

使用 函数名.defaults 以元组形式查看所有默认参数的值

默认值参数必须出现在函数参数列表的最右端，且任何一个默认值参数右边不能有非默认值参数。

（2）关键参数
（3）可变长度参数

（四）return语句

• return语句
用于从一个函数中返回并结束函数的执行，同时还可以通
过其从函数中返回一个值。
• 无论return语句
出现在函数的什么位置，一旦得到执行将直接结束函数的
执行。
• 函数的返回值类型由return语句返回值的类型来决定
• 如果函数没有return语句或者没有执行return语句，
执行了不带任何值的return语句，则函数都默认为返回
空值None。

（五）变量作用域——变量起作用的范围 可分为 局部变量、全局变量

局部变量：只在对应函数内部起作用 函数结束时自动被删除
全局变量：其作用域为全局的 能同时作用于函数内外 用关键字global来定义

（六）lambda表达式

用来声明匿名函数 既没有函数名字的临时使用的小函数 只可以包含一个表达式 且该表达式的计算结果为函数的返回值，不允许包含其他复杂的语句 但在表达式中可以调用其他函数

高级话题：

文件操作：

文件打开详解：

#filename property.py
import os
def printfp():
 fh = open('sample.txt')
 try:
    print('file name : %s' % fh.name)
    print('access mode: %s' % fh.mode)
    print('encoding : %s' % fh.encoding)
    print('closed : %s' % fh.closed)
 finally:
     fh.close()
#end printfp
if __name__=='__main__':
 printfp()
#end if

向文本文件写入内容：

二进制文件： 使用pickle写入数据
import pickle

异常处理结构与程序调试：

常用的异常类：

常见的异常处理结构：
try…except结构 （base exception基本异常类）

try…except…else结构

for arg in sys.argv[1:]:
try:
f = open(arg,‘r’)
except IOError:
print(‘cannot open’,arg)
else:
print(arg,‘has’,len(f.readlines()),‘lines’)