python基础知识
变量及类型
1、变量可以是任意的数据类型，在一个程序中用一个变量名表示
2、变量名必须是大小写英文、数字和下划线的组合，且不能以数字开头
标识符和关键字
python一些有特殊功能的标识符，就是所谓的关键字
关键字，是python已经使用了的，所以不允许开发者自己定义和关键字相同的名字的标识符
>>>import keyword
>>> keyword.kwlist
'False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'
输出
普通输出
print("hello world")
格式化输出
age=18
print("我的名字是%s，我的国籍是%s"%("小莫","中国"))
print("我今年%d岁"%age)
常用的格式符号
| 格式符号 | 转换 |
|---|---|
| %c | 字符 |
| %s | 通过str()字符串转换来格式化 |
| %i | 有符号十进制整数 |
| %d | 有符号十进制整数 |
| %u | 无符号十进制整数 |
| %o | 八进制整数 |
| %x | 十六进制整数（小写字母） |
| %X | 十六进制整数（大写字母） |
| %e | 索引符号 |
| %E | 索引符号 |
| %f | 浮点实数 |
| %g | %f和%e的简写 |
| %G | %f和%E的简写 |
分割以及换行
print("aaa","bbb","ccc")#默认以空格分割
print("www","baidu","com",sep=".")#用.分割
print("hello",end="")#不换行
print("world",end="\n")#换行
输入
password=input("请输入密码")
print("您刚刚输入的密码是:",password)
print(type(password))#password的类型是字符串类型
强制类型转换
a=int("123")
b=a+10
print(b)
运算符
| 运算符 | 描述 |
|---|---|
| + | 加 |
| - | 减 |
| * | 乘（若是字符串则返回一个被重复若干次的字符串） |
| / | 除 |
| % | 取模 |
| ** | 幂 |
| // | 向下取整除 |
逻辑运算符
| 运算符 | 描述 |
|---|---|
| and | 如果x是False，x and y返回False，否则返回y的计算值 |
| or | 如果x是True，它返回x的值，否则它返回y的计算值 |
| not | 如果x是True，返回False。如果x是False，返回True |
成员运算符
| 运算符 | 描述 |
|---|---|
| in | 如果在指定的序列中找到值，返回True，否则返回False |
| not in | 如果在指定的序列中没有找到值，返回True，否则返回False |
身份运算符
| 运算符 | 描述 |
|---|---|
| is | is是判断两个标识符是不是引用自一个对象 |
| is not | is not是判断两个标识符是不是引用自不同对象 |
注意：id(x)函数用于获取对象内存地址
判断语句和循环语句
if
if 要判断的条件:
条件成立时，要做的事情
if True:
print ("Answer")
print ("True")
else:
print ("Answer")
print ("False") # 缩进不一致，会导致运行错误
score = 77
if score>=90 and score<=100:
print('本次考试，等级为A')
elif score>=80 and score<90:
print('本次考试，等级为B')
elif score>=70 and score<80:
print('本次考试，等级为C')
elif score>=60 and score<70:
print('本次考试，等级为D')
#elif score>=0 and score<60:
else: #elif可以else一起使用
print('本次考试，等级为E')
if嵌套
if 条件1:
满足条件1 做的事情1
满足条件1 做的事情2
...(省略)...
if 条件2:
满足条件2 做的事情1
满足条件2 做的事情2
...(省略)...
import 与 from…import
在 python 用 import 或者 from…import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc,
thirdfunc
将某个模块中的全部函数导入：from somemodule import \*
import random #引入随机库
computer = random.randint(0,2) #随机生成0、1、2中的一个数字，赋值给变量computer
for
for 临时变量 in 列表或者字符串等:
循环满足条件时执行的代码
name = 'chengdu'
for x in name:
print(x)
while
i = 0
while i<5:
print("当前是第%d次执行循环"%(i+1))
print("i=%d"%i)
i+=1
break和continue
i = 0
while i<10:
i = i+1
print('----')
if i==5:
break
print(i)
i = 0
while i<10:
i = i+1
print('----')
if i==5:
continue
print(i)
字符串、列表、元组、字典
python中字符串可以使用单引号、双引号和三引号括起来，使用反斜杠\转义特殊字符
1、包含单引号的字符串
假如你想定义一个字符串my_str，其值为： I’m a student，则可以采用如下方式，通过转义字符 \ 进
行定义。
my_str = 'I\'m a student'
也可以不使用转义字符，利用双引号直接进行定义。
my_str = "I'm a student"
2、包含双引号的字符串
假如你想定义一个字符串my_str，其值为： Jason said “I like you” ，则可以采用如下方式，通过转义
字符 \ 进行定义。
my_str = "Jason said \"I like you\""
也可以不使用转义字符，利用单引号直接进行定义。
my_str = 'Jason said "I like you"'
| 转义字符 | 描述 |
|---|---|
| 在行尾时 | 续行符 |
| \\ | 反斜杠符号 |
| \’ | 单引号 |
| \’’ | 双引号 |
| \a | 响铃 |
| \b | 退格 |
| \000 | 空 |
| \n | 换行 |
| \v | 纵向制表符 |
| \t | 横向制表符 |
| \r | 回车 |
| \f | 换页 |
| \oyy | 八进制数，yy代表的字符，如：\o12代表换行 |
| \xyy | 十六进制数，yy代表的字符，如：\x0a代表换行 |
| \other | 其他的字符以普通格式输出 |
字符串的截取和连接
str='chengdu'
print(str) # 输出字符串
print(str[0:-1]) # 输出第一个到倒数第二个的所有字符
print(str[0]) # 输出字符串第一个字符
print(str[2:5]) # 输出从第三个开始到第五个的字符
print(str[2:]) # 输出从第三个开始后的所有字符
print(str * 2) # 输出字符串两次
print(str + '你好') # 连接字符串
print(str[:5]) # 输出第五个字母前的所有字符
print(str[0:7:2]) # [起始：终止：步长]
print('------------------------------')
print('hello\nchengdu') # 使用反斜杠(\)+n转义特殊字符
print(r'hello\npython') # 在字符串前面添加一个 r，表示原始字符串，不会发生转义
字符串常见操作
| 序号 | 方法及描述 |
|---|---|
| 1 | capitalize() 将字符串的第一个字符转换为大写 |
| 2 | center(width, fillchar) 返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。 |
| 3 | count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end指定则返回指定范围内 str 出现的次数 |
| 4 | bytes.decode(encoding=“utf-8”, errors=“strict”) Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由str.encode() 来编码返回。 |
| 5 | encode(encoding=‘UTF-8’,errors=‘strict’) 以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’ |
| 6 | endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果beg 或者 end指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False. |
| 7 | expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是8 。 |
| 8 | find(str, beg=0, end=len(string)) 检测 str 是否包含在字符串中，如果指定范围 beg 和 end，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1 |
| 9 | index(str, beg=0, end=len(string)) 跟find()方法一样，只不过如果str不在字符串中会报一个异常. |
| 10 | isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True,否则返回False |
| 11 | isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False |
| 12 | isdigit() 如果字符串只包含数字则返回 True 否则返回 False. |
| 13 | islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False |
| 14 | isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False |
| 15 | isspace() 如果字符串中只包含空白，则返回 True，否则返回 False |
| 16 | istitle() 如果字符串是标题化的(见 title())则返回 True，否则返回 False |
| 17 | isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False |
| 18 | join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串 |
| 19 | len(string) 返回字符串长度 |
| 20 | [ljust(width, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格 |
| 21 | lower() 转换字符串中所有大写字符为小写 |
| 22 | lstrip() 截掉字符串左边的空格或指定字符。 |
| 23 | maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。 |
| 24 | max(str) 返回字符串 str 中最大的字母。 |
| 25 | min(str) 返回字符串 str 中最小的字母。 |
| 26 | [replace(old, new , max]) 把 将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。 |
| 27 | rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找. |
| 28 | rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始. |
| 29 | [rjust(width, fillchar]) 返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度width 的新字符串 |
| 30 | rstrip() 删除字符串字符串末尾的空格. |
| 31 | split(str="", num=string.count(str)) num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串 |
| 32 | [splitlines(keepends]) 按照行(’\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。 |
| 33 | startswith(substr, beg=0,end=len(string)) 检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。 |
| 34 | [strip(chars]) 在字符串上执行 lstrip()和 rstrip() |
| 35 | swapcase() 将字符串中大写转换为小写，小写转换为大写 |
| 36 | title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见istitle()) |
| 37 | translate(table, deletechars="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中 |
| 38 | upper() 转换字符串中的小写字母为大写 |
| 39 | zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充0 |
| 40 | isdecimal() 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。 |
列表
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套)。
列表是写在[]之间、用逗号分隔开的元素列表。
列表索引值以0为开始值，-1为从末尾的开始位置。
列表可以使用+操作符进行拼接，使用*表示重复。
列表的格式
变量A的类型为列表
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
比C语言的数组强大的地方在于列表中的元素可以是不同类型的
testList = [1, 'a']
打印列表
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
print(namesList[0])
print(namesList[1])
print(namesList[2])
#或
namesList = ['xiaoWang','xiaoZhang','xiaoHua']
for name in namesList:
print(name)
常用操作
| 操作名称 | 操作方法 | 举例 |
|---|---|---|
| 访问列表中的元素 | 通过下标直接访问 | print(list1[0]) |
| 列表的切片 | 使用[: :] | list1[2:5:2] |
| 遍历列表 | 通过for循环 | for i in list1: print(i) |
| 【增】新增数据到列表尾部 | 使用append | list1.append(5) |
| 【增】列表的追加 | 使用extend方法 | list1.extend(list2) |
| 【增】列表数据插入 | insert方法 | list1.insert(1, 3) |
| 【删】列表的删除 | del ：我们通过索引删除指定位置的元素。remove：移除列表中指定值的第一个匹配值。如果没找到的话，会抛异常。 | del list1[0] list1.remove(1) 注意两种方法的区别 |
| 【删】弹出列表尾部元素 | 使用pop | list1.pop() |
| 【改】更新列表中的数据 | 通过下标原地修改 | list1[0] = 8 |
| 【查】列表成员关系 | in 、not in | 2 in list1 |
| 列表的加法操作 | + | list3 = list1 + list2 |
| 【排】列表的排序 | sort方法 | list1.sort() |
| 【排】列表的反转 | reverse | list1.reverse() |
| 获取列表长度 | len（） | |
| 获取列表元素最大值 | max（） | |
| 获取列表元素最小值 | min（） | |
| 其它类型对象转换成列表 | list（） |
列表的嵌套
#encoding=utf-8
import random
# 定义一个列表用来保存3个办公室
offices = [[],[],[]]
# 定义一个列表用来存储8位老师的名字
names = ['A','B','C','D','E','F','G','H']
i = 0
for name in names:
index = random.randint(0,2)
offices[index].append(name)
i = 1
for tempNames in offices:
print('办公室%d的人数为:%d'%(i,len(tempNames)))
i+=1
for name in tempNames:
print("%s"%name,end='')
print("\n")
print("-"*20)
元组
tuple与list类似，不同之处在于tuple的元素不能修改。tuple写在小括号里，元素之间用逗号隔开。
元组的元素不可变，但可以包含可变对象，如list。
注意：定义一个只有1个元素的tuple，必须加逗号
创建空元组
tup1 = ()
元组的定义
tup1 = (50) # 不加逗号，类型为整型
print(type(tup1)) #输出<class 'int'>
tup2 = (50,) # 加逗号，类型为元组
print(type(tup2)) #输出<class 'tuple'>
元组的访问
tup1 = ('Google', 'baidu', 2000, 2020)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合
tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
删除元组后，再次访问会报错
tup = ('Google', 'baidu', 2000, 2020)
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)
元组常用操作
| 操作名称 | 操作方法 | 举例 |
|---|---|---|
| 访问元组中的元素 | 通过下标直接访问 | print(tuple1[0]) |
| 遍历元组 | 通过for循环 | for i in tuple1: print(i) |
| 元组的切片 | 使用[: :] | tuple1[2:5:2] |
| 元组的加法操作 | + | tuple3 = tuple1 + tuple2 |
| 元组成员关系 | in | 2 in list1 |
| 得到重复元素数量 | count | tuple1.count(1) |
| 获取元组长度 | len（） | |
| 获取元组元素最大值 | max（） | |
| 获取元组元素最小值 | min（） | |
| 其它类型对象转换成元组 | tuple（） |
字典
字典是无序的对象集合，使用键-值( key-value )存储，具有极快的查找速度。
键(key)必须使用不可变类型。
同一个字典中，键(key)必须是唯一的。
变量info为字典类型：
info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
字典和列表一样，也能够存储多个数据
列表中找某个元素时，是根据下标进行的
字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）
字典的每个元素由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值
根据键访问值
info = {'name':'吴彦祖','age':18}
print(info['age']) # 获取年龄
# print(info['sex']) # 获取不存在的key，会发生异常
print(info.get('sex')) # 获取不存在的key，获取到空的内容，不会出现异常
若访问不存在的键，则会报错
info['sex']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'sex'
在我们不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值：
>>> age = info.get('age')
>>> age #'age'键不存在，所以age为None
>>> type(age)
<type 'NoneType'>
>>> age = info.get('age', 18) # 若info中不存在'age'这个键，就返回默认值18
>>> age
18
字典常用操作
| 操作名称 | 操作方法 | 举例 |
|---|---|---|
| 访问字典中的元素（1） | 通过key访问，key不存在会抛出异常 | print(dict1[“小明”]) |
| 访问字典中的元素（2） | 通过get方法，不存在返回None,不抛出异常 | print(dict1.get(“”小明)) |
| 遍历字典（1） | 通过for循环，只能获取key | for key in dict1: print(key, dict1[key]) |
| 遍历字典（2） | 配合items方法，获取key和val | for key, val in dict1.items(): print(key, val) |
| 直接获取所有key和value | 使用keys和values方法 | print(dict1.values()) print(dict1.keys()) print(dict1.items())#得到所有的项 |
| 修改val | 直接通过key修改 | dict1[‘小明’] = 2003 |
| 新增键值对 | 直接新增 | dict1[‘小李’] = 2005 |
| 字典元素的删除 | 通过key删除 | del dict1[‘小李’] |
| 字典元素的弹出 | 通过pop方法 | dict1.pop(“小李”) |
| 判断key是否存在 | in | “key” in dict1 |
| 合并字典 | update | dict1.update(dict2) |
| 把两个列表转为字典 | dict+zip方法 | dict(zip(list1,list2)) |
| 把一个嵌套列表转为字典 | dict方法 | dict2 = dict([[‘key1’, ‘value1’]]) |
| 清除字典内的元素 | clear方法 | dict1.clear() |
| 获取字典长度 | len（） | |
| 获取最大的key | max（） | |
| 获取最小的key | min（） | |
| 其它类型对象转换成字 | dict（） | dict([(1, 2), (2, 3)]) |
集合
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
set是无序的，重复元素在set中自动被过滤。
| 操作名称 | 操作方法 | 举例 |
|---|---|---|
| 遍历集合 | for | for i in set1: print(i) |
| 更新集合 | update方法 | set1.update(set2) |
| 向集合中添加新元素 | add方法 | set1.add(5) |
| 移除集合中的元素 | remove方法 | set1.remove(5) |
| 弹出元素 | pop方法 | val = set1.pop() |
| 清除元素 | clear方法 | set1.clear() |
| 删除集合 | del | del set1 |
| 获取集合长度 | len() | |
| 获取最大元素 | max() | |
| 获取最小元素 | min() | |
| 其他类型对象转换成集合 | set() |
小结
| 是否有序 | 是否可变类型 | |
|---|---|---|
| 列表[ ] | 有序 | 可变类型 |
| 元组( ) | 有序 | 不可变类型 |
| 字典{ } | 无序 | key不可变val可变 |
| 集合{ } | 无序 | 可变类型（不重复） |
函数
如果在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以把具有独
立功能的代码块组织为一个小模块，这就是函数
函数定义和调用
def 函数名():
代码
# 定义完函数后，函数是不会自动执行的，需要调用它才可以
printInfo()
函数参数
def add2num(a, b):
c = a+b
print c
add2num(11, 22) #调用带有参数的函数时，需要在小括号中，传递数据
保存返回值
#定义函数
def add2num(a, b):
return a+b
#调用函数，顺便保存函数的返回值
result = add2num(100,98)
#因为result已经保存了add2num的返回值，所以接下来就可以使用了
print result
返回多个值
>>> def divid(a, b):
... shang = a//b
... yushu = a%b
... return shang, yushu
...
>>> sh, yu = divid(5, 1)
>>> sh
5
>>> yu
1
本质是利用了元组
局部变量和全局变量
局部变量，就是在函数内部定义的变量
不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用
在函数外边定义的变量叫做 全局变量
全局变量能够在所有的函数中进行访问
如果在函数中修改全局变量，那么就需要使用 global 进行声明，否则出错
如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的
文件操作
文件打开与关闭
在python，使用open函数，可以打开一个已经存在的文件，或者创建一个新文件open(文件名，访问模式)
f = open('test.txt', 'w')
| 访问模式 | 说明 |
|---|---|
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。 |
| w | 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头 |
| w+ | 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
关闭文件
# 新建一个文件，文件名为:test.txt
f = open('test.txt', 'w')
# 关闭这个文件
f.close()
文件读写
写write
f = open('test.txt', 'w')
f.write('hello world, i am here!')
f.close()
读read
f = open('test.txt', 'r')
content = f.read(5)
print(content)
print("-"*30)
content = f.read()
print(content)
f.close()
读数据（readlines）
就像read没有参数时一样，readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素
#coding=utf-8
f = open('test.txt', 'r')
content = f.readlines()
print(type(content))
i=1
for temp in content:
print("%d:%s"%(i, temp))
i+=1
f.close()
读数据（readline）
#coding=utf-8
f = open('test.txt', 'r')
content = f.readline()
print("1:%s"%content)
content = f.readline()
print("2:%s"%content)
f.close()
文件的相关操作
文件重命名
import os
os.rename("毕业论文.txt", "毕业论文-最终版.txt")
删除文件
import os
os.remove("毕业论文.txt")
创建文件夹
import os
os.mkdir("张三")
获取当前目录
import os
os.getcwd()
改变默认目录
import os
os.chdir("../")
获取目录列表
import os
os.listdir("./")
删除文件夹
import os
os.rmdir("张三")
错误与异常
print '-----test--1---'
open('123.txt','r')
print '-----test--2---'
打开一个不存在的文件123.txt，当找不到123.txt 文件时，就会抛出给我们一个IOError类型的错
误，No such file or directory：123.txt （没有123.txt这样的文件或目录）
当Python检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所
谓的"异常"
捕获异常 try…except…
try:
print('-----test--1---')
open('123.txt','r')
print('-----test--2---')
except IOError:
pass
此程序看不到任何错误，因为用except 捕获到了IOError异常，并添加了处理的方法
pass 表示实现了相应的实现，但什么也不做；如果把pass改为print语句，那么就会输出其他信息
except捕获多个异常
try:
print num
except IOError:
print('产生错误了')
except捕获的错误类型是IOError，而此时程序产生的异常为 NameError ，所以except没有生效
应改为
try:
print num
except NameError:
print('产生错误了')
捕获异常实例
#coding=utf-8
try:
print('-----test--1---')
open('123.txt','r') # 如果123.txt文件不存在，那么会产生 IOError 异常
print('-----test--2---')
print(num)# 如果num变量没有定义，那么会产生 NameError 异常
except (IOError,NameError):
#如果想通过一次except捕获到多个异常可以用一个元组的方式
#except Exception as result: #Exception可以捕获所有异常
try…finally…
在程序中，如果一个段代码必须要执行，即无论异常是否产生都要执行，那么此时就需要使用
finally。 比如文件关闭，释放锁，把数据库连接返还给连接池等
import time
try:
f = open('test.txt')
try:
while True:
content = f.readline()
if len(content) == 0:
break
time.sleep(2)
print(content)
except:
#如果在读取文件的过程中，产生了异常，那么就会捕获到
#比如 按下了 ctrl+c
pass
finally:
f.close()
print('关闭文件')
except:
print("没有这个文件")
Python 爬虫
爬虫知识
1、什么是爬虫
网络爬虫，是一种按照一定规则，自动抓取互联网信息的程序或者脚本。由于互联网数据的多样性和资源的有限性，根据用户需求定向抓取相关网页并分析已成为如今主流的爬取策略。
2、爬虫可以做什么
你可以爬取妹子的图片，爬取自己想看的视频等等，只要你能通过浏览器访问的数据都可以通过爬虫获取。
3、爬虫的本质是什么
模拟浏览器打开网页，获取网页中我们想要的那部分数据。
基本流程
1、准备工作
通过浏览器查看分析目标网页，学习编程基础规范。
2、获取数据
通过HTTP库向目标站点发起请求，请求可以包含额外的header等信息，如果服务器能正常响应，会得到一个Response，便是所要获取的页面内容。
3、解析内容
得到的内容可能是HTML、json等格式，可以用页面解析库、正则表达式等进行解析。
4、保存数据
保存形式多样，可以存为文本，也可以保存到数据库，或者保存特定格式的文件。
扫一扫
8万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
