提示:本文主要讲解的是python的基础知识,参考的书籍是张健、张良均主编的《Python编程基础》
提示:这里可以添加本文要记录的大概内容:
本文是基于Windows系统平台安装的Python3.6.0版本,代码主要是在pycharm上编写。关于Python版本的安装和配置环境变量,请参考张健、张良均主编的《Python编程基础》。
提示:以下是本篇文章正文内容,下面案例可供参考
示例:pandas 是基于NumPy 的一种工具,该工具是为了解决数据分析任务而创建的。
print('hello world')
print('hello','world')
character = 'hello world'
print(character)
character = input("input your character:")
print(character)
x = input('first:')
y= input('second:')
print(x+y)#输出是没有空格的
character = input("input your character:")
print(character)```
#-*-coding:utf-8-*-
#coding:utf-8
#coding=utf-8
#!e:/python/python36 声明路径
#这是一个使用#号的单行注释
#这是一个使用#号的多行注释
#这是一个使用#号的多行注释
#这是一个使用#号的多行注释
2.单引号注释
'''
该多行注释使用的是3个单引号
该多行注释使用的是3个单引号
该多行注释使用的是3个单引号
'''
3.双引号注释
"""
该多行注释使用的是3个双引号
该多行注释使用的是3个双引号
该多行注释使用的是3个双引号
"""
a = 'welcome '
b = 'to '
c = 'HuaXian'
total = a + \
b + \
c
print(total)
print("Welcome "
"to "
"HuaXian")
a = 'welcome ';b = 'to ';c = 'HuaXian'
print(a+b+c)
Python最具有特色的就是以缩进的方式来标识代码块,不需要使用大括号,代码看起来更加简洁明朗(同一个代码块的语句必须保证相同的缩进空格数,至于缩进的空格数Python并没有硬性要求***)。
标识符有以下规定:
import keyword
print(keyword.iskeyword("chenxiaoda")) # 得加输出
print(keyword.kwlist) # 查看python中所有的保留字
在python中,变量不需要提前声明,但是一旦创建了一个变量,就必须要给该变量赋值(在C,JAVA中,必须提前声明变量)
x = 4
print(id(x)) # id():查看变量的地址
strExample = "我是一个字符串"
print(len(strExample)) # len():查看字符串长度
a = b = c = 1
print(a, b, c) # 一个值赋给多个变量
a, b, c = 1, 2, "abc"
print(a, b, c) # 多个变量同时赋值
数值型数据类型 | 中文解释(示例) |
---|---|
int | 整数类型 (10、100、1000) |
float | 浮点型 (1.0,0.11、1e-12) |
bool | 布尔型(True:1、False:0) |
complex | 复数(1+1j、0.123j、1+0j) |
print(int(1.56), int(0.123), int(-1.2), int()) # 浮点型转化成整形
print(int(True), int(False)) # 布尔型转化成整形
# print(int(1+23j)) #TypeError: can't convert complex to int:复数没有办法转化
print(bool(1), bool(2), bool(0)) # 整形转化成布尔型 非0的数值转化为布尔型都为True
print(bool(1.0), bool(2.5), bool(0.0)) # 浮点型转化成布尔型 数值0转化为布尔型为False
print(bool(1 + 23j), bool(23j)) # 复数转化成布尔型
# 用bool函数分别对空、空字符、空列表、空元组、空字典(或者集合)进行转化时都为空,如果是非空,结果时True(除去非数值0的情况)
print(bool(), bool(''), bool(""), bool([]), bool({}))
字符型数据可以理解成是一种文本。
- 一、标识字符串
1.单引号(’ ‘);2.双引号(" ");3.三引号(’‘’ ‘’')
print('hello world') # 单引号标识字符串
print("hello world") # 双引号标识字符串(与单引号功能相同,但不能混合使用)
print('''hello \
world''') # 三引号标识字符串 \:字符串在下一行继续,而不是开始一个新行
- 二、转义字符
print('What\'s happened', 'and quotes(\\)') # 反斜杠\:还可以进行字符转义 (单引号中不能直接出现单引号,输出\也需要加\:即\\ )
print("What's happened", "and Double quotes(\")") # (双引号中可以直接出现单引号,但不可以直接出现双引号,也需要反斜杠\)
print('D:\name\python')
print(r'D:\name\python') #还可以给字符串前加r后者R来指定原始字符串。
类型 | 实列 |
---|---|
字符串 | P Y T H O N |
索引 | 0 1 2 3 4 5 6 |
负索引 | -6 -5 -4 -3 -2 -1 |
- 四、字符串基本操作
(1)提取指定位置的字符( [x] )
word = 'python' # python中的字符串数组没有固定的约束格式
print(word[1], word[0], word[-1]) # 正约束:第一个字母从0开始,往右查 负约束:从1开始,从左查
运行结果为:
(2)字符串切片 ( [x:y] )
特别的:
第2个索引越界:将将被切片字符串实际长度替代;
第1个索引越界:返回空字符串 第1个索引值大于第2个索引值:返回空字符串
print(word[0:3], word[:3], word[4:]) # 截取第1~3个字符、截取第1~3个字符、截取第5~最后一个字符
print('python is' + 3 * ' good', ' python is ''good') # 加号拼接字符串 相邻字符串自然拼接
sentence = 'Life is short,you need something.'
print(sentence[:23] + 'python') # 字符串的修改:只能找到要修改的索引位置 然后加修改值(目前的知识)
运算符 | 描述(示例) |
---|---|
+ | 加(10+20,结果为30) |
- | 减(20-10,结果为10) |
* | 乘(10*20,结果为200) |
/ | 除:不管商为整数还是浮点数,结果始终为浮点数(20/10,结果为2.0) |
% | 取模(23%10,结果为3) |
** | 幂(2**3,结果为8) |
// | 取整除:返回商的整数部分(23//10,结果为2) |
python提供了type(x)函数,可以来查看x的数据类型。
print(2 / 1, type(2 / 1)) # python中的/:不管商为整数还是浮点数,结果始终为浮点数
print(2 // 1, type(2 // 1)) # python中的//:取整除,即返回商的整数部分
运算符 | 描述(示例) |
---|---|
== | 等于:比较两个对象是否相等(1==2,返回False) |
!= | 不等于:比较两个对象是否不相等(1!=2,返回True) |
> | 大于:返回x是否大于y(1>2,返回False) |
< | 小于:返回x是否小雨y(1<2,返回True) |
>= | 大于等于:返回x是否大于等于y(1>=2,返回False) |
<= | 小于等于:返回x是否小于等于y(1<=2,返回True) |
Python还提供了两个可以进行字符与编码转换的函数。
print(1 == 1, 1 != 2) # 比较运算符
print('a' == 'b', 'a' != 'b');
print('a' < 'b', 'a' > 'b')
print(ord('a'), ord('b')) # ord():将ASCLL字符转换为对应的数值
print(chr(97), chr(98)) # chr():将数值转换为对应的ASCLL字符
print('#' < '$') # ASCLL字符的比较就是对应的数值大小的比较
运算符 | 描述(示例) |
---|---|
= | 简单赋值(c=a+b等效于将a+b的运算结果赋值给c) |
+= | 加法赋值(a+=b等效于a=a+b) |
-= | 减法赋值(a-=b等效于a=a-b) |
*= | 乘法赋值(a*=b等效于a=a*b) |
/= | 除法赋值(a/=b等效于a=a/b ) |
%= | 取模赋值(a%=b等效于a=a%b) |
**= | 幂赋值(a**=b等效于a=a**b) |
//= | 整除赋值(a//=b等效于a=a//b) |
# 赋值运算与c,java语言类似:= 、+=、-=、*=、/=、%=、**=、//=
a = 1 + 2;
print(a)
print("a: ", a);
a += 4;
print("a += 4 特殊赋值运算后,a=: ", a);
通常,数字是使用十进制的,按位运算符会自动将输入的十进制数转为二进制数,在进行相应的运算。
运算符 | 描述(示例) |
---|---|
& | 位与运算:对应的两个值为1,则为1,否则则为0(a&b= 000 1100 =12) |
l | 位或运算:对应的两个值只要有一个为1,则为1(alb= 0011 1101=61) |
^ | 异或运算:对应的两个值相异,则为1(a^b= 0011 0001 =49) |
~ | 取反运算:对应的每个值取反:1变成0;0变成1((若开头为0:是正数,正数的补码是他本身;若开头为1:是负数,负数的补码需要减1取反)~a=1100 0011,:减1:1100 0010、符号位不变再取反:1011 1101= -61) |
<< | 左移运算:对应的值全部左移若干位,高位丢弃,低位补0(a<<2=1111 0000=240) |
>> | 右移运算:对应的值左移若干位(a>>2=0000 1111) |
# 位运算 二进制位数1111 1111 :128|64|32|16 8|4|2|1
a = 60 # a对应的二进制:a = 0011 1100
b = 13 # b对应的二进制: b = 0000 1101
print(a & b) # 按位与运算 &:按位运算,都为1则为1;否则为0 a&b=0000 1100=12
print(a | b) # 按位或运算 |: 按位运算,只要有一个为1则为1,否则为0 a|b=0011 1101=61
print(a ^ b) # 按位异或运算 ^: 按位运算,当两对应的二进制位相异时为1,否则为0 a^b=0011 0001=49
print(~a) # 按位取反运算符~: 对应的每个二进制位取反,1变为0,0变为1 ~a=1100 0011=128+64+2+1=195
print(a << 2) # 左移运算符<<: 运算数的各二进位全部左移若干位,由“<<”右边的数指定移动的位数,高位丢弃,低位补0 a<<2 = 1111 0000=
print(a >> 2) # 右移运算符>>:运算数的各二进位全部右移若干位,由“>>”右边的数指定移动的位数 a>>2 =0000 1111=15
运行结果如下:
运算符 | 描述(示例) |
---|---|
and | 布尔“与”(x and y):若x为False,则为False;否则返回y的计算值。(a and b,返回22) |
or | 布尔“或”(x or y):若x是Ture,则为True;否则返回y的计算值。(a or b,返回11) |
not | 布尔“非”(not(x)):若x为Ture,则为False;若x为False,则为True。(not (a and b),返回False |
# 逻辑运算符 and、or、not (不是很懂)
a = 11;
b = 12;
print('a=11,b=22')
print('a and b =', a and b) # (布尔“与”)x and y,如果x为False,返回False;否则它返回y的计算值
print('a or b =', a or b) # (布尔”或“)x or y,如果x是True,他返回True;否则它返回y的计算值
print('not(a and b) = ', not (a and b)) # (布尔”非“)not(x),如果x为True,返回False,如果x为False,它返回true
print(True & True, True and True) # 按位&,逻辑 and
print(True & False, True and False)
print(True | False, True or False) # 按位|、逻辑or
print(False | False, False or False)
成员运算符包括:字符串、列表或元组。其作用是判断某指定值是否存在于某一序列中。
运算符 | 描述(示例) |
---|---|
in | 若在指定的序列中找到值,返回True,否则返回False(x in y:x在y序列中,返回True) |
not in | 如果在指定的序列中没有找到值,返回True,否则返回False (x not y,x不在y序列中,返回True) |
List = [1, 2, 3, 0, [4,5], 'Python3']
print(List)
print(1 in List)
print([1] in List)
print(3 in List)
#print([4,5] in list) #这句程序有点问题,会出错 TypeError: argument of type 'type' is not iterable
#print('Python' in list) #这句程序有点问题
#print('Python3' in list) #这句程序有点问题
身份运算符用于比较两个对象的内存地址。
运算符 | 描述(示例) |
---|---|
is | 用于判断两个标识符是不是引用自一个对象(x is y,如果id(x)等于id(y),返回结果1) |
is not | 用于判断两个标识符是不是引用自不同对象(x is not y,如果id(x)不等于id(y),返回1) |
a = 11; b = 11; print('a=11,b=11')
print(a is b); print(a is not b)
print(id(a),id(b)) #查看id地址
在python的应用中、通常运算的形式是表达式。表达式由运算符和操作数组成。
运算符 | 描述 |
---|---|
** | 指数(最高运算符) |
~ + - | 按位翻转、一元加号和减号 |
* / % // | 乘、除、取模和取整除 |
+ - | 加法减法 |
>> << | 右移、左移运算符 |
& | 按位与运算符 |
^ | 按位或运算符 |
<= < > >= | 比较运算符 |
<> == != | 等于运算符 |
= %= /= //= -= += *= **= | 赋值运算符 |
is is not | 身份运算符 |
in not in | 成员运算符 |
not or and | 逻辑运算符 |
python的数据结构主要分为以下两个部分
#创建一个列表(list)并进行增删改查操作
mylist=[1,2.0,['three','four',5],6.5,True] #创建混合数据类型的嵌套列表
print(mylist)
empty_list = [] #创建一个空列表
print(empty_list)
mylist1 = list((1,2.0,['three','four',5],6.5,True)) #list():将传入的数据结构对象转换为列表类型 注意:得用圆括号和方括号把元素括起来
print(mylist1)
print(type(mylist1)) #type():查看对象类型
mylist2 = list(['one','two','three']) #向函数list传入一个列表对象
print(mylist2)
mylist3 = list('one') #向函数list传入一个字符串
print(mylist3)
mylist4 = ['Sunday','Monday','Tuesday','Wednesday','Thrusday','Friday']
print(mylist4[1]) #正索引:从0开始(从左到右)
print(mylist4[-3]) #负索引:从-1开始(从右到左)
运行结果如下:
2.列表的切片操作提取—sequence_name[start:end:step]
mylist5 = [10,20,30,40,50,60,70,80,90,100] #0,1,2,3,,,,,,,
print(mylist5[2:7]) #提取从第3~8个元素之间的元素 左闭右开
print(mylist5[1:9:2]) #提取从第1~10元素之间的元素,步长为2
print(mylist5[-2:-8:-2]) #提取倒数第1~8个元素之间的元素,步长为2
#省略起始索引
print(mylist5[:-7:-2]) #提取从结尾向左到倒数第7个元素前的所有元素,步长为2
#省略终止索引
print(mylist5[6:]) #提取从第7个元素到列表右端最后一个元素之间的所有元素
#同时省略起始和终止索引
print(mylist5[::2]) #提取所有元素,步长为2
print(mylist5[::-1]) #####列表反转
##添加列表元素 append():此函数一次只能追加一个元素
month = ['January','February','March','April','May','June']
month.append('Jury')
print(month)
运行结果如下:
(2)extend:使用extend能够将另一个列表添加到列表末尾,相当于两个列表进行拼接。(extend可以追加多个元素,得到的效果与使用自增运算(+=)相同)
#添加多个元素 extend():能够将另一个列表添加到列表末尾
month_copy = month.copy() #创建一个元素副本,在修改列表元素部分解释
print(month_copy)
others = ['Augest','September','Novermber','December']
month.extend(others)
print(month)
month_copy+=others
print(month_copy) #extnd()与+=的效果一样
运行结果如下:
(3)insert:使用insert也能够向列表中添加一个元素,若插入位置超出列表尾端,则会插入列表最后,这相当于append的效果。(特别的,insert可以在指定位置添加)
#insert():向列表中添加一个元素
month.insert(9,'October') #特别的::insert可以在指定位置添加,就想在列表某个位置插入一个元素一样。
print(month)
month.insert(20,'None') #插入位置超出列表尾端,则会插入列表最后,相当于append的效果
print(month)
运行结果如下:
['January', 'February', 'March', 'April', 'May', 'June', 'Jury', 'Augest', 'September', 'October', 'Novermber', 'December']
['January', 'February', 'March', 'April', 'May', 'June', 'Jury', 'Augest', 'September', 'October', 'Novermber', 'December', 'None']
#del:实质是赋值语句(=)的逆过程
month_copy = month.copy()
del month_copy[-1]
print(month_copy)
运行结果如下:
(2)使用pop语句删除列表元素:利用元素位置对元素进行删除操作。将元素传入pop语句中,将会获取该元素,并将其在列表中删除,相当于把列表中的元素抽离出来。(若不指定元素位置,默认使用索引-1)
#pop():利用元素位置可以对元素进行删除操作 pop语句将默认使用索引-1
month_copy = month.copy()
print(month_copy.pop(3)) #获取并删除第4个元素
del_element = month_copy.pop() #将最后一个元素赋值给一个变量并在副本中删除
print(del_element) #查看删除元素
print(month_copy) #查看副本
运行结果如下:
(3)使用remove语句删除列表元素:将指定元素传入remove语句。则列表中第一次出现的该元素会被删除。
#remove():可以将指定元素进行删除 列表中第一个出现的该元素会被删除
month.remove('None')
print(month)
运行结果如下:
最简单的方法就是提取该元素并进行赋值操作。
month[0]='一月'
print(month)
运行结果如下;
为什么要创建一个副本?
对于可变类型的数据结构,直接在对象上进行元素的增删改查等操作,处理结果将直接影响对象本身。**
#为什么要创建副本
a=[1,2,3,4]
b=a
a.append(5)
print(a)
print(b)
copy方法作用
如果不希望修改操作直接作用于列表对象本身,可以使用copy函数创建一个完全一样的“副本”,实质上,这个“副本”已经是另一个列表对象,只是内容上与原列表对象完全相同而已
除了copy方法外 ,使用切片操作和list函数 也能达到同样的效果。
#copy方法操作
a = [10,20,30,40,50]
b=a.copy() #使用copy方法创建副本
c=a[:] #使用切片操作创建副本
d=list(a) #使用list函数创建副本
print(id(a),id(b),id(c),id(d))
b[2]='three'
print(b);print(a);print(c);print(d)
#index():查询指定元素在列表中第一次出现的位置索引
letter = ['A','B','C','D','A','D','C','B']
print(letter.index('C')) #若查询的字符不在列表中,则会报错
print('A' in letter)
列表方法和函数 | 说明 |
---|---|
list.count | 记录某个元素在列表中出现的次数 |
list.sort | 对列表中的元素进行排序(默认升序);reverse=True:降序。结果会改变原列表内容 |
sorted | 与list。sort作用一样。但不改变原列表内容 |
list.reverse | 反转列表中的各元素 |
len | 获得列表长度,即元素个数 |
+ | 将两个列表合并成一个列表 |
* | 重复合并同一个列表多次 |
letter = ['A','B','C','D','A','D','C','B']
#count():记录某个元素在列表中出现的次数
print(letter.count('A'))
#sort():对列表中的元素进行排数,默认为升序,sort(reverse = True):降序排序
#sorted():与sort()的作用一样,但不改变列表内容
sorted(letter);print(letter)
letter.sort();print(letter)
letter.sort(reverse=True);print(letter)
#reverse:反转列表中的元素
season = ['sprint','summer','autumn','winter']
season.reverse()
print(season)
#len: 获取列表的长度,即元素个数
print(len(season))
#+:将两个列表合并成一个列表 *:重复合并同一个列表多次
print([1,2,3]+[4,5,6])
print([11,22,33]*3)
# 使用圆括号()创建元组 将列表转换为元组
mytuple1 = (1, 2.4, ('three', 'four'), [True, 5], False)
print(mytuple1)
mytuple2 = 2, True, 'five', 3.5
print(mytuple2)
# 使用tuple函数创建 将列表转换为元组
mytuple1 = tuple([1, 2.4, ('three', 'four'), [True, 5], False])
print(mytuple1)
mytuple2 = tuple((2, True, 'five', 3.5))
print(mytuple2)
empty_list = tuple()
print(empty_list) # 注意:元组使用圆括号来包括元素,,,,列表使用方括号
# 元组索引访问提取
mytuple3 = ('china', 'Americal', 'England', 'France')
print(mytuple3[0]) # 若传入的索引超出元组索引范围,则结果会返回一个错误
# 元组切片操作
print(mytuple3[-2::-1]) # 提取元组倒数第2个元素到左端之间的所有元素
print(mytuple3[1:10]) # 超出元素索引范围
### 元组解包
A, B, C, D = mytuple3 # 将元组中的各元素分别赋值给对应的变量
print(A, B, C)
x, y, z = 1, True, 'one' # 利用元组解包进行多个变量赋值
print(x, y, z) # z输出的是one,而不是‘one'
元组方法和函数 | 说明 |
---|---|
tuple.count | 记录某个元素在元组中出现的次数 |
tuple.index | 获取元素在元组当中第1次出现的位置索引 |
sorted | 创建对元素进行排序后的列表(不仅仅是元组的排序) |
len | 获取元组长度,即元组元素个数 |
+ | 将两个元组合并为一个元组 |
* | 重复合并同一个元组为一个更长的元组 |
# 使用count函数进行元素计数
mytuple4 = ('A', 'D', 'C', 'A', 'C', 'B', 'B', 'A')
print(mytuple4.count('B'))
# 使用index函数获取元素在元组中第一次出现的位置索引
mytuple4.index('C')
# 使用sorted函数对元组元素进行排序
print(sorted(mytuple4))
# 使用len函数获取元组长度
print(len(mytuple4))
# +:合并两个元组,*:重复合并元组
print((1, 2, 3) + (4, 5, 6))
print((10, 20, 30, 40) * 3)
步骤如下:
# -*-coding:utf-8-*-
task_tuple = ['pen', 'paper', 10, False, 2.5] # 创建一个列表
print(type(task_tuple)) # 查看对象的数据类型
task_tuple = tuple(task_tuple) # 转换列表对象为元组类型
print(type(task_tuple)) # 查看对象的数据类型
Index = task_tuple.index(False) # 查询元素位置索引
bool = task_tuple[Index] # 提取元组元素
print(bool) # 查看提取元素
字典的键与值:
1.字典的每个元素都有对应的键,元素就是键所对应的值。
2.键与值共同构成一个映射关系:键—值(key:value),称为键值对。字典中会包含多个键值对。
3.键必须使用不可变数据类型的对象,如数字、字符串、元组等。并且键不允许重复。
4.值可以是任意类型,并且在字典中可以重复。
对于重复创建的键,采用最后出现的对应值
mydict1 = {'myint': 1, 'myfloat': 3.14, 'mystr': 'name',
'myint': 100, 'mytuple': (1, 2, 3),'mydict': {}} # 对于重复的键,采用最后出现的对应值
print(mydict1)
empty_dict = {}
print(empty_dict)
双值子序列:实际上就是只包含两个元素的序列
mydict1 = dict([('myint', 1), ('myfloat', 3.14), ('mystr', 'name'),
('myint', 100), ('mytuple', (1, 2, 3)), ('mydict', {})])
print(mydict1)
mydict2 = dict(zero=0, one=1, two=2)
print(mydict2)
empty_dict = dict()
print(empty_dict)
mydict3 = {'spring': (3, 4, 5), 'summer': (6, 7, 8), 'autumn': (9, 10, 11), 'winter':'冬天'}
print(mydict3['autumn'])
print(mydict3['winter'])
运行结果如下:
为了避免传入键不存在而导致出错,python提供了两种处理方法:
print('Winter' in mydict3)
运行结果为:False
get能够灵活第处理元素的提取:
print(mydict3.get('summer'))
print(mydict3.get('Winter'))
print(mydict3.get('winter', 'Not in this dict'))
print(mydict3.get('Winter', 'Not in this dict'))
在Python的内置数据结构中,字典和列表时最为灵活的数据类型。他们都是可变的数据结构:都能进行增、删、改、查等操作。
country = dict(China = 'Beijing',
America = 'Washington',
Britain = 'London',
French = 'Paris',
Canada = 'Ottawa')
country_copy = country.copy()
country_copy['Russian'] = 'Moscow'
print(country_copy)
运行结果如下:
{'China': 'Beijing', 'America': 'Washington', 'Britain': 'London', 'French': 'Paris', 'Canada': 'Ottawa', 'Russian': 'Moscow'}
(1).update:将两个字典中的键值对进行合并,传入字典中的键值对会复制添加到调用函数的字典对象中。若两个字典中存在相同键,传入字典中的键所对应的值会替换掉函数字典对象中的原有值,实现值更新的效果。
others = dict(Australia = 'Canberra',
Japan = 'tokyo',
Canada = 'OTTAWA')
country.update(others)
print(country)
运行结果如下:
{'China': 'Beijing', 'America': 'Washington', 'Britain': 'London', 'French': 'Paris', 'Canada': 'OTTAWA', 'Australia': 'Canberra', 'Japan': 'tokyo'}
# del
country_copy = country.copy()
del country_copy['Canada']
print(country_copy)
# pop
old_value = country.pop('Canada')
print(old_value)
print(country)
# clear
country_copy=country.copy()
country_copy.clear()
print(country_copy)
运行结果如下:
{'China': 'Beijing', 'America': 'Washington', 'Britain': 'London', 'French': 'Paris', 'Australia': 'Canberra', 'Japan': 'tokyo'}
OTTAWA
{'China': 'Beijing', 'America': 'Washington', 'Britain': 'London', 'French': 'Paris', 'Australia': 'Canberra', 'Japan': 'tokyo'}
{}
# 修改字典元素
country['Japan'] = 'Tokyo' # 键值已有,覆盖新值
print(country)
country['Henan'] = 'Huaxian' # 键值没有,添加新值
print(country)
运行结果如下:
{'China': 'Beijing', 'America': 'Washington', 'Britain': 'London', 'French': 'Paris', 'Australia': 'Canberra', 'Japan': 'Tokyo'}
{'China': 'Beijing', 'America': 'Washington', 'Britain': 'London', 'French': 'Paris', 'Australia': 'Canberra', 'Japan': 'Tokyo', 'Henan': 'Huaxian'}
查询某个键是否在字典中,也可以使用之前讲的in进行判断。
字典方法中有3种方式用于提取键值信息(返回的结果均是各自的迭代形式、可以通过list将返回结果转换为列表类型,同时配合in的使用,半段值和键值对是否存在与字典中):
# 判断键知否存在于字典当中
print('Canada' in country)
# 获取所有键
all_keys = country.keys()
print(all_keys)
# 判断值是否存在于字典当中
all_values = country.values()
print(all_values)
print(list(all_values))
print('Beijing' in all_values)
# 判断键值对是否存在于字典当中
all_items = country.items()
print(all_items)
print(('America', 'Washington') in all_items)
print(list(all_items))
运行结果为:
False
dict_keys(['China', 'America', 'Britain', 'French', 'Australia', 'Japan', 'Henan'])
dict_values(['Beijing', 'Washington', 'London', 'Paris', 'Canberra', 'Tokyo', 'Huaxian'])
['Beijing', 'Washington', 'London', 'Paris', 'Canberra', 'Tokyo', 'Huaxian']
True
dict_items([('China', 'Beijing'), ('America', 'Washington'), ('Britain', 'London'), ('French', 'Paris'), ('Australia', 'Canberra'), ('Japan', 'Tokyo'), ('Henan', 'Huaxian')])
True
[('China', 'Beijing'), ('America', 'Washington'), ('Britain', 'London'), ('French', 'Paris'), ('Australia', 'Canberra'), ('Japan', 'Tokyo'), ('Henan', 'Huaxian')]
可以利用值查询键
因为提取完的全体键和值的索引正好是一一对应,构成原字典中的键值对
# 提取字典中值为True所对应的值
test = {'A': 100, 'B': 300, 'C': True, 'D': 'Python'}
print(test)
keys = list(test.keys())
values = list(test.values())
print(keys); print(values)
print(keys[values.index(True)]) # 先查询True对应的索引值,因为一一对应,然后按其索引,可提取对应的键
步骤如下:
# -*-coding:utf-8-*-
score = {'Math': 96, 'English': 86, 'Chinese':95.5,
'Biology': 86, 'Physics': None}
score['History'] = 88
del score['Physics']
new_value = round(score['Chinese'])
score['Chinese'] = new_value
print(score['Math'])
print(score)
集合类型数据结构包括可变集合与不可变集合。
myset1 = {'A', 'B', '1', '2', '数学', 'A', '数学'}
print(myset1)
myset2 = set([2, 3, False, 2.5, 'one', 2, 'one'])
print(myset2)
empty_set = set()
print(empty_set)
print(type(empty_set))
# 创建不可变集合
myset3 = frozenset([2, 3, 2, 'one', frozenset([1, 2]), True])
print(myset3)
empty_frozenset = frozenset()
print(empty_frozenset)
prin(type(empty_frozenset))
A = {'足球', '游泳', '羽毛球', '乒乓球'}
B = {'篮球', '乒乓球', '羽毛球', '排球'}
print('A=', A, '\nB=', B)
print('A | B = ', A | B)
print(A.union(B)) # 使用集合方法union函数获取并集
print('A & B=', A & B)
print(A.intersection(B)) # 使用集合方法intersection函数获取交集
print('A - B=', A - B)
print(A.difference(B)) # 使用集合方法difference函数获取差集
print('A ^ B=', A ^ B)
print(A.symmetric_difference(B)) # 使用集合方法symmetric_difference函数获取异或集合
**
集合关系常用函数和符号 | 函数说明 |
---|---|
<=或issubset() | 判断一个集合是否为另一个集合的子集,如过是,则集合A中所有元素都是集合B中的元素 |
< | 判断一个集合是否为另一个集合的真子集。如果是,则集合B中除了包含集合A中的所有元素,还包括A中没有的其他元素 |
>=或issuperset() | 判断一个集合是否为另一个集合的超集。如果是,则集合A包含了B中所有元素 |
》 | 判断一个集合是否为另一个集合的真超集。如果是,则集合B中除了包含集合A中的所有元素,还包括B中没有的其他元素 |
# 关于集合,子集,真子集,超集,真超集的运算
C = {'足球', '乒乓球', '游泳'}
print('A=', A, '\nB=', B, '\nC=', C)
print("C是否为A的子集:", C <= A)
print(C.issubset(A))
print('C是否为A的真子集:', C < A, '\nA是否为A的真子集:\n', A < A)
print("C是否为A的超集:", A >= C)
print(A.issuperset(C))
print('C是否为A的真超集:', C < A, '\nC是否为C的真超集:', A < A)
set.add | 向可变集合增添一个元素。 |
---|---|
set.update | 向可变集合添加其他集合的元素,即合并两个集合 |
set.pop | 删除可变集合中的一个元素,当集合对象是空集时,则返回错误。 |
set.remove | 删除可变集合中指定的一个元素 |
set.clear | 清空可变集合中的所有元素,返回空集 |
in | 查询元素是否存在于集合当中 |
len | 获取集合当中元素的个数 |
set.copy | 复制可变集合的内容并创建一个副本对象 |
# 可变集合的常见操作
myset4 = {'red', 'green', 'blue', 'yellow'}
myset4_copy = myset4.copy()
others = {'black', 'white'}
myset4.add('orange')
myset4.update(others)
print(myset4)
print(myset4.pop())
print(myset4)
myset4.remove('yellow')
myset4_copy.clear()
print(myset4_copy)
print('green' in myset4)
print(len(myset4))
步骤如下:
# -*-coding:utf-8-*-
set1 = ['apple', 'pear', 'watermelon', 'peach']
set2 = list(('pear', 'banana', 'orange', 'peach', 'grape'))
set1 = set(set1)
set2 = set(set2)
print(type(set1))
print(type(set1))
print(set1)
print(set2)
print(set1 | set2)
print(set1 & set2)
print(set1 - set2)
print(set2.difference(set1))
if 表达式1 :
分支
if 布尔表达式1 :
分支一
elif 布尔表达式2 :
分支二
else :
分支三
步骤如下:
# -*- coding:utf-8 -*-
score = eval(input('请输入成绩:'))
if score >= 90:
print('恭喜,您的成绩等级为A')
elif 80 <= score < 90:
print('恭喜,您的成绩等级为B')
elif 70 <= score < 80:
print('加油,您的成绩等级为C')
elif 60 <= score < 70:
print('加油,您的成绩等级为D')
else:
print('请下次好好努力,您的成绩等级为E')
for a in ['e', 'f', 'g']:
print('\t', a)
for a in 'string':
print(a)
while 布尔表达式:
程序段
s = 0
while s <= 1:
print('计数:',s)
s = s+1
'''
s = 1
while (s <= 1):
print('无限次循环')
'''
for i in range(0, 5):
print(i)
for i in range(0, 6, 2): # 2可以理解为i=i+2
print(i)
# 直接使用for循环难以改变序列元素
L = [1,2,3]
for a in L:
a += 1
print(L)
# 结合range与len函数来遍历序列并修改元素
for i in range(len(L)):
L[i] += 1
print(L)
# break
s = 0
while True:
s +=1
if s == 6:
break
print(s)
for i in range(0,10):
print(i)
if i == 1:
break
# continue
s = 3
while s >= 0:
s -= 1
if s == 1:
continue
print(s)
for i in range(0, 3):
if i == 1:
continue
print(i)
# pass
for i in range(0,3):
if i == 1:
pass
print('pass块在0·1之间占位,不做任何事情')
print(i)
# -*- coding:utf-8 -*-
# 连加
vec = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
m = 0
for i in vec:
m = m + 1
print(m)
# 连乘
n = 1
for i in vec:
n = n * i
print(n)
嵌套循环就是在一个循环中嵌入另一个循环。python语言是允许在一个循环体里面嵌入另一个循环。例如:
关于如何创建一个n*n,元素全为0的数组
参考网址1:python-Numpy学习之(二) numpy库(ones,zeros,eyes函数)
参考网址2:numpy中的zeros函数
# for-for循环的嵌套
import numpy as np
num = np.zeros((3, 3)) #用mp。zeros()函数创建一个3*3的元素为0的数组。
print('初始数组为:\n', num)
for i in range(0, 3):
for j in range(0, 3):
num[i, j] = i * j
print('改变后的数组为:\n', num)
# for-while循环的嵌套
for i in range(0, 11):
while i > 8:
print(i * 10)
break
在循环中放入条件语句,才可以使得循环能够做更多的事情。
# for循环与条件语句的组合
print('10~15之间:')
for x in range(10, 15): # 判断10·15之前的质数
for i in range(2, x):
if x % i == 0:
j = x / i
print('%d 等于%d * %d' % (x, i, j))
break
else:
print('%d是一个质数' % x)
break
# while循环与条件语句的组合
count = 0
print('打印0~5的数:count>3时,打印其平方')
while count < 5: # 打印0~5:count>3时,打印其平方
if count > 3:
print(count**2)
else:
print(count)
count = count + 1
# -*- coding: utf-8 -*-
# 冒泡排序
# python中互换两个元素可直接使用:a,b = b,a
mppx = [1, 8, 2, 6, 3, 9, 4, 12, 0, 56, 45]
for i in range(len(mppx)):
for j in range(i+1):
if mppx[i] < mppx[j]:
mppx[i], mppx[j] = mppx[j], mppx[i]
print(mppx)
# dict的迭代
d = {'a': 1, 'b': 2, 'c': 3}
for key in d:
print(key)
# for循环同时引用两个变量
for x, y in [(1, 1), (2, 4), (3, 9)]:
print(x, y)
# for循环同时引用三个变量
for x, y, z in [(1, 2, 3), (4, 5, 6), (7, 8, 9)]:
print(x, y, z)
map的用法:
map(函数,列表):map根据提供的函数对指定序列做映射。如果要对列表中所有元素依次进行函数处理,都是靠for循环实现,map就是定义来实现循环的,但是map实现出来的是一个生成器,所以还要用list转出来。
filter的用法:
filter(函数,列表):filter是筛选函数。
lambde的用法:
lambda(参数,函数返回): lambda是一个匿名函数。;。
lambda(参数,函数返回);map(函数,列表)
# 创建列表解析
list00 = list(map(lambda x: x**3, range(6)))
print(list00)
list1 = [x ** 3 for x in range(6)]
print(list1)
seq = [1, 2, 3, 4, 5, 6, 7, 8]
list01 = list(filter(lambda x: x % 2 ==1, seq))
print(list01)
list2 = [x for x in seq if x % 2==0]
print(list2)
# 列表解析式的嵌套循环
list3 = [(i, j) for i in range(0, 3) for j in range(0, 3)]
print(list3)
list4 = [(i, j) for i in range(0, 3) if i < 1 for j in range(0, 3) if j > 1]
print(list4)
python中format函数用于字符串的格式化
# -*- coding: utf-8 -*-
# 完整的数字金字塔
num = eval(input('请输入一个整数:'))
print('数字金字塔显示如下:')
level = 1 # level表示金字塔的高度,即层数
while level <= num: # 高度不超过层数
kk = 1 # 每一层计数
t = level
length = 2 * t - 1
while kk <= length:
if kk == 1:
if kk == length:
print(format(t, str(2 * num - 1) + 'd'), '\n')
break
else:
print(format(t, str(2 * num + 1 - 2 * level) + 'd'), '', end='')
t -= 1
else:
if kk == length:
print(t, '\n')
break
elif kk <= length / 2:
print(t, '', end='')
t -= 1
else:
print(t, '', end='')
t += 1
kk += 1
level += 1
R语言 是用于统计分析、绘图的语言和操作环境。R是属于GNU系统的一个自由、免费、源代码开放的软件,它是一个用于统计计算和统计制图的优秀工具。
Python的函数中,参数不需要声明数据类型(但是这有利也有弊(不清楚参数的数据类型而输入错误的参数))。
自定义函数的格式如下:
def 函数名(形参):
函数体
renturn 结果
Python中的函数参数主要有4种:位置参数、关键字参数、默认参数、可变参数。
# -*- coding: utf-8 -*-
def interest(money, day=1, interest_rate=0.05):
income = 0
income = money*interest_rate * day/365
print(income)
interest(5000) # 默认参数的值可传可不传
interest(10000, 1, 0.05)
# 任意数量的位置可变参数
def exp(x, y, *args):
print('x:', x)
print('y:', y)
print('args:', args)
exp(1, 5, 66, 55, 'abc')
# 任意数量的关键字可变参数
def exp(x, y, *args, **kwargs):
print('x:', x)
print('y:', y)
print('args:', args)
print('kwargs:', kwargs)
exp(1, 2, 2, 4, 66, a='c', b=1)
# 返回函数值
def interest_r(a, b):
A = a+1
B = b+1
print("方法中A的值为:", A)
return B
A = 1
B = 1
print('A的初值为:%d,B的初值为:%d' % (A, B))
B = interest_r(A, B)
print('A的现值为:%d,B的初值为:%d' % (A, B))
list1 = list(range(0, 10, 2)) # 将start = 0,stop = 10,step = 2的顺序传入
print(list1)
list2 = list(range(10, 0, 2)) # 调转start与stop的顺序后传入
# print(list2) 运行结果为:[]
list3 = list(range(10, 2, 0)) # 调转全部参数的顺序后传入
# print(list3) 运行结果出错
list4 = list(range(0, 10, 1))
print(list4)
list5 = list(range(10)) # range只有stop时,默认从start=0开始,步长step=1.
print(list5)
# 关键字参数调用
interest(money=5000, day=7, interest_rate=0.06)
interest(day=7, money=5000, interest_rate=0.06)
interest(5000, day=7, interest_rate=0.06) # 位置参数与关键字参数混合使用
interest(5000, interest_rate=0.06, day=7)
interest(7, money=5000, interest_rate=0.06) # 混用时,位置参数对应的位置不能改变 结果变错
# interest(money=5000, 7, interest_rate=0.05) #关键字参数在位置参数前面,结果报错
# 可变参数调用
arg = [0, 10, 2]
arg = list(range(*arg))
print(arg)
def user(username, age, **kwargs):
print('username:', username,
'age:', age,
'other:', kwargs)
user('john', 27, city='guangzhou', job='Data Analyst')
kw = {'age': 27, 'city': 'guangzhou', 'job': 'Data Analyst'}
user('john', **kw)
# 嵌套函数
def mean(*args):
# m = 0
def sum(x):
sum1 = 0
for i in x:
sum1 += i
return sum1
# m = sum(args) / len(args)
# return m
return sum(args) / len(args)
ave = mean(1, 2, 3, 4, 5, 6, 7, 8, 9)
print(ave)
# 局部变量
def sum2(*arg):
sum1 = 0
for i in range(len(arg)):
sum1 += arg[i]
return sum1
sum1 = 0
print(sum2(1, 2, 3, 4, 5))
print(sum1)
运行结果如下:
2. 全局变量:定义在函数体外面的变量为全局变量
# 全局变量
sum1 = 10
def fun():
sum1 = 100
sum_global = sum1 + 100
print('同时存在全局变量sum1=10,局部变量sum1=100,则结果为:')
# sum1 += 1 # 全局变量不能在函数体内修改和赋值
return sum_global
print(fun())
# 使用global,在函数体内对全局变量赋值
sum1 = 0
def sum2(*arg):
global sum1
for i in range(len(arg)):
sum1 += arg[i]
return sum1
print(sum1)
print(sum2(1, 3, 5, 7))
print(sum1)
print(sum2(1, 3, 5, 7))
任务:方差计算公式的一个推导公式为平方的均值减去均值的平方:
1.构建求和函数sum及平方和函数。
2. 构建求均值函数mean,需要调用求和函数的结果。
3. 构建求方差函数var,需调用求平方和函数及求均值函数的结果。
4. 在方差函数中内建求平方和函数及求均值函数,并在求均值函数中在内建一个求和函数。
# -*- coding: utf-8 -*-
def var(*args): # 构建主体方差函数
def mean(z): # 内建求均值函数
def sum(x): # 内建求和函数
sum1 = 0;
for i in x:
sum1 += i
return sum1
return sum(args) / len(args) # 平均值 = 和 / 长度
def sums(y): # 内建求平方和函数
sum2 = 0
for i in y:
sum2 += i**2
return sum2
return sums(args) / len(args) - mean(args)**2 # 方差 = 平方和的均值 - 均值的平方
print(var(1, 2, 3, 4, 5, 6, 7, 8, 9))
格式:lambda 函数参数:返回值
- lambda定义的是单行函数,如果需要复杂的函数,应使用def语句。
- lambda语句可以包含多个参数。
- lambda语句有且仅有一个返回值。
- lambda语句中的表达式不能含有命令,且仅有一条表达式。(避免匿名函数䣌滥用)
# lambda创建匿名函数
example = lambda x: x ** 3
print(example)
print(example(2))
from math import log # 引用math库中的对数函数
def function_log(base): # 创建一个范围值为:以base为底的匿名对数函数
return lambda x: log(x, base)
my_log = function_log(3) # 调用对数函数,其底数值设置为3
print(my_log(9)) # 使用对数函数,还要设置其真数
格式:map(func,list)
作用:在执行时,序列对象(list)中的每个元素,按照从左到右的顺通过把函数(funx)一次作用在list的每个元素上,得到一个新的llist并返回。
注意:map函数不改变原有的list,只是返回一个新的list。
重要应用:从键盘上输入一个数组
num = list(map(int,input(“请输入一组数(以空格隔开):”).split()))
# map函数
def add(x):
x += 3
return x
num = list(range(10))
# num = list(map(int,input("请输入一组数(以空格隔开):").split())) # 从键盘上输入一组数
num1 = list(map(add, num)) # 普通的调用函数实现
num2 = list(map(lambda x: x+3, num)) # 速度快,可读性强
print(num)
print(num1)
print(num2)
斐波那契函数:
当n<=2时:f(n)=1
当 n>2 时: f(n)=f(n-1)+f(n-2)
计算过程如下(n=3):
(1)n=3,fib(3),判断为fib(3-1)+fib(3-2)。
(2)先看fib(3-1),即fib(2),返回结果为2。
(3)再看fib(3-2),即fib(1),返回结果为2。
(4)最后计算第(1)步,结果为fib(n-1)+fib(n-2)=2+2=4,将结果返回。
# fib函数求解斐波那契额数列
def fib(n):
if n <= 2:
return 2
else:
return fib(n-1) + fib(n-2)
num = eval(input('请输入项数n:'))
print('第{}项为:{}'.format(num, fib(num)))
print('斐波那契数列为:')
for i in range(1,num+1):
print('{}'.format(fib(i)), end='\t')
格式:filter(func,list)
作用:filter函数接收一个函数(func)和一个元素列表(list),这个func函数的作用是对每个元素进行判断。
# filter函数
list1 = [1, 4, 67, 9, 12, 17]
list2 = list(filter(lambda x: x % 2 == 1, list1))
print(list1)
print(list2)
s1 = 'i love python and R'
s2 = list(filter(lambda c: c != 'o', s1))
s2 = ''.join(s2) # 变为字符型
print(s1)
print(s2)
# -*- coding: utf-8 -*-
# 正常方式
def add(x):
x +=3
return x
new_nums = []
for i in range(10):
new_nums.append(add(i))
print(new_nums)
# lambda函数方式(匿名函数)
lam = lambda x: x+3
n2 = []
for i in range(10):
n2.append(lam(i))
print(n2)
# 或者
lam = lambda x: x+3
n1 = []
[n1.append(lam(i)) for i in range(10)]
print(n1)
# map函数
nums = list(range(10))
aa = list(map(lambda x: x+3, nums)) # map(add, nums)
# [aaa**2 for aaa in aa] # 速度快,可读性强
print(aa)
# 更快
bb = list(map(lambda x: x+3, list(range(10))))
print(bb)
关于封装:本任务将实现简单的封装方法,将自定义函数封装为函数模块,然后导入模块,在调用里面的函数。
导入模块的函数,步骤如下:
# 文件名为 steak.py
def make_steak(d, *other):
print('Make a steak wll done in %d ' % d + 'with the other:')
for o in other:
print('-' + o)
import steak
steak.make_steak(9, 'salad')
steak.make_steak(8, 'red wine', 'salad', 'coffee')
格式:from 文件名 import 函数名
作用:导入模块中的指定函数。
用法:使用这种方法,调用函数时就不需要加模块的前缀,直接调用它的函数名称即可。
缺点:但如果导入模块的函数较多,则这种方法比较麻烦。
# 导入指定函数
from steak import make_steak
make_steak(9, 'salad')
make_steak(8, 'red wine', 'salad', 'coffee')
格式:from 文件名 import 星号(*)
作用:将所有函数都导入当前程序中。
用法:采用没有模块前缀的方法可以调用模块中的所有函数。
缺点:如果模块中的函数名称和项目程序中的名称相同,就会倒是混乱或者程序出错,所以一般不要采用这种导入方法。
# 导入指定函数
from steak import make_steak
make_steak(9, 'salad')
make_steak(8, 'red wine', 'salad', 'coffee')
关于Python的导入方法,最佳的是,只导入所需使用的函数,或者导入整个模块,并用前缀的方式表示。这能让代码更清晰,更容易阅读和理解。
# 指定函数别名
from steak import make_steak as ms
ms(9, 'salad')
ms(8, 'red wine', 'salad', 'coffee')
# 指定模块别名
import steak as s
s.make_steak(9, 'salad')
s.make_steak(8, 'red wine', 'salad', 'coffee')
# -*- coding: utf-8 -*-
# 导入封装好的函数模块
import var
var1 = var.var(1, 2, 3, 4, 5, 6, 7, 8, 9)
print(var1)
# 导入模块中特定的函数var.var
from var import var
var2 = var(1, 2, 3, 4, 5, 6, 7, 8, 9)
print(var2)
# 给var函数指定别名为fangcha
from var import var as fangcha
var3 = fangcha(1, 2, 3, 4, 5, 6, 7, 8, 9)
print(var3)
# 给var函数模块指定别名V
import var as V
var4 = V.var(1, 2, 3, 4, 5, 6, 7, 8, 9)
print(var4)
# 导入模块中的所有函数
from var import *
var5 = var(1, 2, 3, 4, 5, 6, 7, 8, 9)
print(var5)
python不只是解释型语言,也是一门面向对象的编程语言,因此自定义对象是python语言的核心之一。
- 面向对象编程(Object Oriented Programming,OPP)即面向对象程序设计。
- 类和对象是OOP中的两个关键内容。
- 在面向对象编程中,以类来构造现实世界中的事物情景,在基于类创建对象来帮助进一步认识、理解、刻画。根据类来创建的对象,每个对象都会自动带有类的属性和特点,还可以按照实际需要赋予每个对象特有的属性,这个过程称为类的实例化。
- 抽象的直接表现形式通常为类。
- 抽象指对显示世界的事物、行为和特征建模、建立一个相关的数据集用于描绘程序结构,从而实现这个模型。
- 抽象不仅包括这种模型的数据属性,还定义了这些数据的接口。
- 从面向对象设计(Object Oriented Design,OOD)角度去看,如果类是从现实对象抽象而来的,那么抽象类就是基于类抽象而来的,可以进行相似编码,或者编入与对象交互的对象中。
- 从现实角度来看,抽象类与普通类的不同之处在于:抽象类只有抽象方法(没有实现功能),该类不能被实例化,只能被继承。且子类必须实现抽象方法。
- 面向过程是分析处解决问题所需要的步骤,然后用函数一步一步实现这些步骤,使用的时候一个一个依次调用即可。
- 面向对象是把构成问题的事物分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描述某个事物在整个解决问题的步骤中的行为。
以下“五子棋”为例:
可以明显看出,面向对象是以功能来划分问题的,而不是循环步骤。
任务描述:
创建一个Car类,为其赋予车轮数(4)、颜色(red)的属性,并定义函数来输出“汽车有4个车轮, 颜色时红色。”及“车行驶在学习的大道上。” ,在调用类的方法(函数)。
在面向对象的程序设计中,类是创建对象的基础,描述了所创建对象共有的属性和方法。它同时也有接口和结构,接口可以通过方法与类或对象进行互操作,而结构表现处一个对象中有什么样的属性。这些都为面向对象编程的3个最重要的特性(封装性、继承性、多态性)提供了实现手段。
定义一个类,格式如下:
在python中,首字母大写的名称指的是类(Car)
如果名称是两个单词,两个单词的首字母都要大写,”驼峰式命名“
函数名称一般用小写字母或者下划线符号连接。
类的函数(方法)的参数都有一个self参数,并默认为第1个参数。
class 类名:
属性列表
方法列表
class Cat():
"""一次模拟猫咪的简单尝试"""
name = 'xinxin'
age = 3
def sleep(self):
"""模拟猫咪被命令睡觉"""
print('%d岁的%s正在沙发上睡懒觉。' % (self.age, self.name))
def eat(self,food):
"""模拟猫咪被命令吃东西"""
self.food = food
print('%d岁的%s再吃%s' % (self.age, self.name, self.food))
cat = Cat()
cat.eat('鱼')
运行结果为:
class Cat():
def sleep(self):
print(self)
new_cat = Cat()
new_cat.sleep()
运行结果为:
无论任何类,都有类的专有方法,它们的特殊性由代码就能看出来,通常是用双下划线“__”开头或者结尾
查看类的属性及方法:
# #查看类的属性及方法
class Example():
pass
example = Example()
print(dir(example)) # 查看类属性
print(dir(Example)) # 查看方法
运行结果为:
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
'__init__', '__init_subclass__', '__le__', '__lt__', '__module__',
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
'__init__', '__init_subclass__', '__le__', '__lt__', '__module__',
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__']
常用的类的专有方法:
类的专有方法 | 功能 |
---|---|
__ init __ | 构造函数,在生成对象时调用 |
__ del __ | 析构函数,解释对象时使用 |
__ repr __ | 打印,转换 |
__ setitem __ | 按照索引赋值 |
__ getitem __ | 按照做因获取值 |
__ len __ | 获得长度 |
__ cmp __ | 比较运算 |
__ call __ | 函数调用 |
__ add __ | 加运算 |
__ sub __ | 减运算 |
__ mul __ | 乘运算 |
__ div __ | 除运算 |
__ mod __ | 求余运算 |
__ pow __ | 乘方 |
任务步骤如下:
# -*- coding utf-8 -*-
class Car():
WheelNum = 4
color = 'red'
def CarInfo(self,name):
self.name = name
print("{}有{}个车轮,颜色是{}".format(self.name, self.WheelNum, self.color))
def run(self):
print("车行驶在学习的大道上!")
car = Car() # 调用Car类
car.CarInfo('玛莎拉蒂')
car.run()
任务描述
创建Car对象,先用构造器构造初始化类的实例对象,赋予属性newWheelNum和newColor,并定义函数,实现输出“车载跑,目标:夏威夷。”,然后创建具体对象,访问对象的属性和方法(函数),最后用机构的方法删除对象。
__ init __是类的一个特殊的方法,每当根据类创建实例时,python都会自动运行它,这就是一个初始化手段,python中的 __ init __方法用于初始化类的实例对象。
c++的构造函数,可创建一个类的实例对象。
而python执行 __ init __ 方法时,实例对象已被构造出来。__ init __方法会在对象构造出来后自动执行,所以可以用于初始化所需要的数据属性。
# 创建对象
class Cat():
"""再次模拟猫咪的简单尝试"""
def __init__(self, name, age):
self.name = name
self.age = age
def sleep(self):
"""模拟猫咪被命令睡觉"""
print('{}岁的{}正在沙发上睡觉'.format(self.age, self.name))
def eat(self, food):
"""模拟猫咪被命令吃东西"""
self.food = food
print('{}岁的{}再吃{}'.format(self.age, self.name, self.food))
cat = Cat('xinxin', 4)
cat.sleep()
cat.eat('fish')
- 创建对象时,默认调用构造方法。同样,删除对象时,也会默认调用析构方法。
- __ del __是类的另一个特殊的方法,当使用del语句删除对象是,会调用它本身的析构函数。
- 另外,当对象在某某个作用域中调用完毕,跳出其作用域的同时,析构函数也会被调用一次,释放内存空间。
# 删除对象
class Animal():
# 构造方法
def __init__(self):
print('---构造方法被调用---')
# 析构方法
def __del__(self):
print('---析构方法被调用---')
cat = Animal()
print(cat)
del cat
print(cat)
执行cat = Animal()的结果:
执行 print(cat)的结果:
执行del cat;print(cat)的结果:
1. 对象的属性
对象的变量由类的每个实例对象拥有。不同对象调用该变量,其变量值改变后,对象之间互不影响。
- 如果在类方法中引用某个属性,则该属性必定是类属性。
- 如果在实例对象方法中引用某个属性(不进行更改),并且存在同名的类属性:若实例对象由该名称的对象属性,则对象属性会屏蔽类属性,即引用的是对象属性;若实例对象没有该名称的对象属性,则引用的是类属性。
- 如果在实例对象方法中更改某个属性,并且存在同名的类属性,此时,若实例对象由该名称的对象属性,则修改的是对象属性;若实例对象没有改名称的实例属性,则会创建一个通名称的对象属性。
- 要修改类属性,如果在类外,则可以通过类对象修改;如果在类里面,则只有在类方法中进行修改。
2. 对象的方法
(1). 对象方法的引用
cat1 = Cat('Tom', 3)
sleep = cat1.sleep
sleep()
cat2 = Cat('Jack', 4)
eat = cat2.eat
eat('fish')
运行结果为:
(2). 对象属性的私有化
print(cat1.age)
print(cat2.name)
运行结果为:
为了防止程序开发人员无意中修改对象的状态,需要对类的数据属性和方法进行私有化。python不支持直接私有方式,为了让方法的数据属性或方法变成私有,只需要在方法的数据属性或方法的名字前面加上双下划线即可。
# 私有化方法
class Cat():
"""再次模拟猫咪的简单尝试"""
def __init__(self, name, age):
self.__name = name
self.__age = age
def sleep(self):
"""模拟猫咪被命令睡觉"""
print('{}岁的{}正在沙发上睡觉'.format(self.__age, self.__name))
def eat(self, food):
"""模拟猫咪被命令吃东西"""
self.__food = food
print('{}岁的{}再吃{}'.format(self.__age, self.__name, self.__food))
def getAttribute(self):
return self.__name,self.__age
cat1 = Cat('Tom', 3)
cat2 = Cat('Jack', 4)
# print("Cat1的名字为:", cat1.name) # 会报错,此时不能从外部访问对象的属性
# print('Cat2的名字为:', cat2.name)
cat1.sleep() # 只能通过设置好的接口函数来访问对象
cat2.eat('fish')
print(cat1.getAttribute())
注释部分的运行结果为:
最终运行结果为:
但是通过双下划线实现的私有化其实是“伪私有化”,实际上还可以从外部访问这些私有数据属性。
特殊的:可以通过: 对象._类名__属性 来访问私有化的属性。
# 特殊的:可以通过: 对象._类名__属性 来访问私有化的属性
print(cat1._Cat__name)
print(cat2._Cat__age)
具体步骤如下:
# -*- coding: utf-8 -*-
class Car():
# 构造器方法
def __init__(self, newWheelNum, newColor):
self.wheelNum = newWheelNum
self.color = newColor
# 功能函数
def run(self):
print('车再跑,目标:夏威夷。')
# 机构函数
def __del__(self):
print('---析构函数方法被调用---')
car = Car(4, 'green')
print('车的颜色为:', car.color)
print('车轮子数量为:', car.wheelNum)
car.run()
del car
# print(car)
任务描述:
流程控制语句中已经接触过迭代方式,这里说的是面向对象过程中对象的迭代。本任务将对Car类进行迭代,增加品牌(brand)和废气涡轮增压(T)两个属性,并依次输出所有属性。
迭代是python最强大的功能之一,是访问集合的一种方式。之前接触到的python容器对象都可以用for循环进行遍历。
for element in [1, 2, 3]: # 列表迭代
print(element)
for element in (1, 2, 3): # 元组迭代
print(element)
for key in {'one': 1, 'two': 2}: # 字典迭代
print(key)
for char in '123':
print(char)
for line in open('myfile.txt'):
print(line)
运行结果如下:
迭代器有两个基本的函数,即iter函数和next函数。
加入for语句在容器对象上调用iter函数,则该函数会返回一个定义next函数的迭代对象,它在容器中逐一访问元素。
当next函数找不到后续元素时,会引发一个StopIteration异常,告知for循环终止。
# iter函数与next函数
L = [1, 2, 3]
it = iter(L)
print(it)
print(next(it))
print(next(it))
print(next(it))
print(next(it))
**迭代器(Iterator)是一个可以记住遍历的位置的对象,**从第1个元素被访问开始,直到所有元素被访问完结束。但是要注意的是,迭代器只能往前,不会后退。
# iter函数应用
class Cat():
def __init__(self, name, age):
self.name = name
self.age = age
self.info = [self.name, self.age]
self.index = -1
def getName(self):
return self.name
def getAge(self):
return self.age
def __iter__(self):
print('名字 年龄')
return self
def next(self):
if self.index == len(self.info) - 1:
raise StopIteration
self.index += 1
return self.info[self.index]
cat = Cat('coffe', 3)
print(cat.getName())
iterator = iter(cat.next, 1)
for info in iterator:
print(info)
1. yieled
在python中,使用生成器(Generator)可以很方便地支持迭代器协议。生成器是一个返回迭代器的函数,它可以通过常规的def函数来定义,但是不用return语句返回,而是用yield语句一次返回一个结果。一般的函数生成值后会退出,但是生成器函数在生成值后会自动挂起暂停执行状态并保存状态信息。这写信息在函数恢复时将再度生效,通过在每个结果之间挂起和几句它们的状态自动实现迭代协议。
# 生成器函数--斐波那契额数列
import sys
def fibonacci(n, w=0):
a, b, counter = 0, 1, 0
while True:
if counter > n:
return
yield a
a, b = b, a + b
print('{},{}'.format(a, b))
counter += 1
f = fibonacci(10, 0)
while True:
try:
print(next(f), end=" ")
except:
sys.exit()
执行yield a 的运行结果:
不执行yield a的运行结果:
2. 生成器表达式
列表解析的一般形式如下。
expr for iter_var in iterable if cond_expr
迭代iterable里所有内容时,每一次迭代后,
把iterable里面满足cond_expr条件的内容放到iter_var中,
在在表达式expr中应用iter_var的内容,最后用表达式的计算值生成一个列表。
例如,生成一个list来保护50以内的所有奇数。
# 列表解析 []
list = [i for i in range(50) if i % 2]
# 生成器表达式 ()
list1 = (i for i in range(100) if i % 2)
print(list)
print(list1)
具体步骤如下:
# -*- coding:utf-8 -*-
class Car():
def __init__(self, brand, newWheelNum, newColor, T):
self.brand = brand
self.wheelNum = newWheelNum
self.color = newColor
self.T = T
self. info = [self.brand, self.wheelNum, self.color, self.T]
self.index = -1
def getBrand(self):
return self.brand
def getnewWheelNum(self):
return self.wheelNum
def getnewColor(self):
return self.color
def getT(self):
return self.T
def __iter__(self):
print('品牌 车轮树 颜色 废气涡轮增压')
return self
def next(self):
if self.index == 3:
raise StopIteration
self.index += 1
return self.info[self.index]
car = Car('BMW', 4, 'red', 2.4)
iterator = iter(car.next, 1)
for info in iterator:
print(info)
任务描述
本任务要在创建的Car类上产生子类Land_Rover,而且要使子类Land_Rover
拥有两恶搞弗雷属性(品牌、颜色)和两个自带属性(车轮数、废气涡轮增压),然后输出子类属性。
继承(Inheritance)时两个类或多个类之间的父子关系,子类继承了父类的所有公用数据属性和方法,并且可以通过编写子类的代码扩充子类的供能。继承实现了数据和方法的重用,减少了代码的冗余度。
继承的特点:
- 在继承中,积累初试化方法__init__不会被自动调用。如果希望子类调用基类的__init__方法,需要在子类的__init__方法中显示调用它。这与C++和C#区别很大。
- 在调用积累的方法时,需要加上基类的类名前缀,且带上self参数变量。注意,在类中调用在该类中定义的方法是不需要self参数的。
- python中总是首先查找对应类的方法,如果在子类中没有对英的方法,python才会在继承链的基类中按顺序查找。
在python继承中,子类不能访问基类的私有成员。
class Cat():
def __init__(self):
self.name = '猫'
self.age = 4
self.info = [self.name, self.age]
self.index = -1
def run(self):
print(self.name, '--再跑')
def getName(self):
return self.name
def getAge(self):
return self.age
def __iter__(self):
print('名字 年龄')
return self
def next(self):
if self.index == len(self.info) - 1:
raise StopIteration
self.index += 1
return self.info[self.index]
class Bosi(Cat):
def setName(self, newName):
self.name = newName
def eat(self):
print(self.name, '--在吃')
bs = Bosi()
print('bs的名字为:', bs.name)
print('bs的年龄为:', bs.age)
bs.run()
bs.setName('波斯猫')
bs.eat()
iterator = iter(bs.next, 1) # 迭代输出父类的属性
for info in iterator:
print(info)
class 子类名(父类名1,父类名2,···)
# 多继承
class A(object):
def __init__(self):
print(" ->Input A")
print(" <-Output A")
class B(A):
def __init__(self):
print(" -->Input B")
A.__init__(self)
print(" <--Output B")
class C(A):
def __init__(self):
print(" --->Input C")
A.__init__(self)
print(" <---Output C")
class D(B, C):
def __init__(self):
print("--->Input D")
B.__init__(self)
C.__init__(self)
print("<---Output D")
d = D()
issubclass(C, B) # 判断一个类是不是类一个类的子孙类
issubclass(C, A)
面向对象的三大特性是指重载、封装和多态。
# 重载
class Cat:
def sayHello(self):
print("喵喵---1")
class Bosi(Cat):
def sayHello(self):
print("喵喵---2")
bosi = Bosi()
bosi.sayHello()
# -*- coding:utf-8 -*-
class Car():
def __init__(self, brand, newWheelNum, newColor, T):
self.brand = brand
self.wheelNum = newWheelNum
self.color = newColor
self.T = T
self.info = [self.brand, self. wheelNum, self.color, self.T]
self.index = -1
def getBrand(self):
return self.brand
def getNeWheelNum(self):
return self.wheelNum
def getNewColor(self):
return self.color
def getT(self):
return self.T
def __iter__(self):
print("品牌 车轮数 颜色 废气涡轮增压")
return self
def next(self):
if self.index == 3:
raise StopIteration
self.index += 1
return self.info[self.index]
class Land_Rover(Car):
def __init__(self, brand, newColor):
self.brand = brand
self.wheelNum = 4
self.color = newColor
self.T = 3
Car.__init__(self, self.brand, self.wheelNum, self.color, self.T)
car = Car('BMW', 4, 'red', 2.4)
iterator = iter(car.next, 1)
for info in iterator:
print(info)
运行结果如下:
本章主要介绍如何处理文件和保存数据,以便让程序使用得更容易,使用户能够读取TXT或CSV格式的文件,以及输出为TXT或CSV格式的文件;介绍如何用Python编程实现对计算机以及文件夹的查询、移动、复制与删除等操作:介绍如何对文件进行压缩与解压等。
文件类型如下:
文件类型 | 扩展名 |
---|---|
文档文件 | .txt .doc .hlp .rtf .html |
压缩文件 | .rar .zip. gz .z |
声音文件 | .mp3 |
图形文件 | .bmp .gif . jpg .pic .png .tif |
系统文件 | .int .sys .dll .adt |
可执行文件 | .exe .com |
可执行批处理文件 | .bat |
任务描述
用python读取瓦尔登湖小说(Walden.txt)文件,并将文档保存到本章程序设置的文件夹里,然后用python读取文件Walden.txt中的数据,打印出来。
1. 打开文件:标识符可指定文件打开模式为读取模式®、写入模式(w)、附加模式(a)或读取和写入文件的模式(r++)。Python默认只读模式打开文件。格式如下:
f = open('e_digits.txt', 'r')
2. 读取文件:使用read函数一次性读取文件的全部内容。
txt = f.read()
print(txt)
3. 关闭文件:调用close函数关闭文件。文件使用完毕后必须关闭,引文文件对象会占用操作系统的资源,并且操作系统同一时间能打开的文件数量也是有限的。
f.close()
# 使用try···finall···结构
try:
f = open('e_digits.txt', 'r')
print(f.read())
finally:
if f:
f.close()
# 使用with语句
with open('e_digits.txt', 'r') as f:
print(f.read())
1. 相对文件路径:如果目标文件实在本项目文件的子文件夹那么需要提供相对文件路径让Python到指定位置查找文件,而该文件是相对于当前运行的程序所在的目录而言的,即相对路径。
# 相对文件路径
# 方法一:
with open('text_file\e_digits.txt', 'r') as f:
print(f.read())
# 方法二:
with open('./text_file/e_digits.txt', 'r') as f:
print(f.read())
2. 绝对文件路径:如果目标文件不在本项目文件夹下,那么需要提供完整准确的存储位置(即绝对文件路径)给程序,不需要考虑当前运行程序存储在什么位置。
(1).反斜杠(\):在绝对路径前面加了r,这是因为在window系统中,读取文件可以用反斜杠(\),但是在字符串中反斜杠被当作转义字符来使用,文件路径可能会被转义,所以需要在绝对文件路径前添加字符r,显示声明字符串不用转义。
# 反斜杠: \
with open(r'D:\Python\PycharmProjects\7\text_file\e_digits.txt', 'r') as f:
print(f.read())
(2). 双反斜杠(\):也可以采用双反斜杠(\)的方式表示路径,此时不需要声明字符串。
# 双反斜杠: \\
with open('D:\\Python\\PycharmProjects\\7\\text_file\\e_digits.txt', 'r') as f:
print(f.read())
(3).正斜杠(/):使用Linux路径表示方式是正斜杠(/),该方法也不需要声明字符串,在Linux及Windows操作系统下均可使用。
# 正斜杠: /
with open('D:/Python/PycharmProjects/7/text_file/e_digits.txt', 'r') as f:
print(f.read())
# for 循环来---读取
file_name = './text_file/e_point.txt'
with open(file_name, 'r') as f:
for line_t in f:
print(line_t)
# 消除换行符
file_name = './text_file/e_point.txt'
with open(file_name, 'r') as f:
for line_t in f:
print(line_t.rstrip())
# read函数读取文件
file_name = './text_file/e_point.txt'
with open(file_name, 'r') as f:
txts = f.read()
print(type(txts))
print(txts)
# readlines 函数
with open('./text_file/e_point.txt') as f:
txts = f.readlines()
print(type(txts))
print(txts)
for txt in txts:
print(txt.strip())
# readline函数
with open('./text_file/e_point.txt') as f:
txt = f.readline()
print(type(txt))
print(txt)
实现打开并读取整个文件Walden.txt。
with open('Walden.txt') as file_object:
contects = file_object.readlines()
print(contects)
任务描述
为实现数据写入写入文件,先使用Python创建列表数据,创建一个包含从1~100的平方的列表;在将数据保存为CSV格式,并命名。
r | 读文本文件 |
---|---|
rb | 读二进制文件 |
w | 写文本文件 |
wb | 写二进制文件 |
# 写入文件
def file_see(file_name):
with open(file_name) as f:
txts = f.readlines() # 将读取到文件内容存入列表中
for txt in txts:
print(txt.strip()) # 删除列表中每个元素的指定换行符
file_name = './text_file/words.txt'
print('文件的初始内容为:')
file_see(file_name)
f = open(file_name, 'w')
f.write('Hello, world!')
print('写完文件的内容(但还没有关闭文件):')
file_see(file_name)
f.close()
print('写完文件后的内容(已经完毕文件):')
file_see(file_name)
file_name = './text_file/data.txt'
f = open(file_name, 'w')
data = list(range(1, 11))
f.write(str(data))
f.close()
file_see(file_name)
# 多行写入
file_name = './text_file/words.txt'
f = open(file_name, 'w')
f.write('Hello, world!')
f.write('I love Python!')
f.close()
print('写入多行数据:')
file_see(file_name)
# 多行写入,每行加\n
f = open(file_name, 'w')
f.write('Hello, world!\n')
f.write('I love Python!')
f.close()
print(r'写入多行语句(每行数据\n):')
file_see(file_name)
# 用with语句写入.txt文件
file_name = './text_file/words.txt'
with open(file_name, 'w') as f:
f.write('Hello, world!\n')
f.write('I love Python!\n')
file_see(file_name)
运行结果为:
要写入特定编码的文本文件,需要给open函数传入encoding函数,将字符串自动转换成指定编码。open函数默认encoding参数为UTF-8。要读取非UTF-8编码的文本文件,例如读取GBK编码的文件,需要给open函数传入encoding参数。
# 写入文件
file_name = './text_file/words.txt'
f = open(file_name, 'w', encoding='gbk')
f.write('Hello,world!')
f.close()
file_see(file_name)
# 添加文件
file_name = './text_file/words.txt'
with open(file_name, 'a') as f:
f.write("What's your favourite language?\n")
f.write("My favorite language is Python too.\n")
file_see(file_name)
**逗号分隔值(Comma-Separated Values, CSV)**有时也称为字符分隔值,是一种通用的、相对简单的文件格式,常应用于在程序之间转移表格数据。
csv文件由任意数目的记录组成,记录间以某种换行符分隔;每条记录由字段组成,字段间的分隔符是其他字符或字符串,最常见的分隔符是符号或制表符。
在编写程序时,可能需要将数据转移到CSV文件里面,在程序中,用命令import csv 可直接调用csv模块进行CSV文件的读写。
# 读取iris数据
import csv
file_name = './text_file/iris.csv'
with open(file_name, 'r') as f:
reader = csv.reader(f)
iris = [iris_item for iris_item in reader]
print(iris)
运行结果为:
[['', 'Sepal.Length', 'Sepal.Width', 'Petal.Length', 'Petal.Width', 'Species'],
['1', '5.1', '3.5', '1.4', '0.2', 'setosa'],
['2', '4.9', '3', '1.4', '0.2', 'setosa'],
['3', '4.7', '3.2', '1.3', '0.2', 'setosa'],
['4', '4.6', '3.1', '1.5', '0.2', 'setosa'],
['5', '5', '3.6', '1.4', '0.2', 'setosa'],
···
(2) 使用csv.DictReader函数,该函数与csv.reader函数类似,接收一个可迭代的对象,能返回一个生成器,但是返回的每一个单元格都放在一个字典的值内,而字典的键则是这个单元格的标题(即列头)。
# csv.DictReader函数读取数据
import csv
file_name = './text_file/iris.csv'
with open(file_name, 'r') as f:
reader = csv.DictReader(f)
iris1 = [iris_item for iris_item in reader]
print(iris1)
运行结果为:
[OrderedDict([('', '1'), ('Sepal.Length', '5.1'), ('Sepal.Width', '3.5'), ('Petal.Length', '1.4'), ('Petal.Width', '0.2'), ('Species', 'setosa')]), OrderedDict([('', '2'), ('Sepal.Length', '4.9'), ('Sepal.Width', '3'), ('Petal.Length', '1.4'), ('Petal.Width', '0.2'), ('Species', 'setosa')]), OrderedDict([('', '3'), ('Sepal.Length', '4.7'), ('Sepal.Width', '3.2'), ('Petal.Length', '1.3'), ('Petal.Width', '0.2'), ('Species', 'setosa')]), OrderedDict([('', '4'), ('Sepal.Length', '4.6'), ('Sepal.Width', '3.1'), ('Petal.Length', '1.5'), ('Petal.Width', '0.2'), ('Species', 'setosa')]),
···
如果用csv.DictReader函数读取CSV文件的某一列,则可以用列的标题(Sepal.Length)查询。
# 读取Name列的内容
file_name = './text_file/iris.csv'
with open(file_name, 'r') as f:
reader = csv.DictReader(f)
column = [iris_item['Sepal.Length'] for iris_item in reader]
print(column)
运行结果为:
['5.1', '4.9', '4.7', '4.6', '5', '5.4', '4.6', '5', '4.4', '4.9', '5.4', '4.8', '4.8', '4.3', '5.8', '5.7', '5.4', '5.1', '5.7', '5.1', '5.4', '5.1', '4.6', '5.1', '4.8', '5', '5', '5.2', '5.2', '4.7', '4.8', '5.4',
···
# 写入列表数据
import csv
file_name = './text_file/test.csv'
with open(file_name, 'w', newline='') as f:
with_csv = csv.writer(f)
with_csv.writerow(iris)
任务描述
os模块和shutil模块是常用的文件模块。通过编写Python程序,即将squares.csv文件及程序文件移动到当前工作目录下的test_file文件夹里,并压缩成RAR格式的压缩包。
os模块是pythpn标准库中的一个用于访问操作系统的模块,包含普遍的操作系统功能,如复制、创建、修改、删除文件及文件夹。
import os
print('操作系统名称为 ', os.name) # 查询操作系统名称
print('文件路径的分隔符为 ', os.sep) # 查询文件路径的分隔符
print('当前系统使用的行终止符为 ', os.linesep) # 查询当前系统使用的行终止符
# 查询工作路径
path = os.getcwd() # 查询当前公祖婆工作目录
print(path)
# 查询指定目录下的文件
files = os.listdir('./text_file')
print(files)
# 删除文件
os.remove('./text_file/test.csv')
print(os.listdir('./text_file'))
# 创建与删除目录
file_name = './text_file/my_file'
os.mkdir(file_name) # 创建文件夹
print(os.listdir('./text_file'))
os.rmdir(file_name) # 删除文件夹
print(os.listdir('./text_file'))
os.path.isdir(name) | 判断name是不是目录,不是目录就返回False |
---|---|
os.path.isfile(name) | 判断name这个文件是否存在,不存在就返回False |
os.path.exists(name) | 判断是否存在文件或目录name |
os.path.getsize(name) | 获得文件大小,如果name是目录,则返回OL |
os.path.abspath(name) | 获得绝对路径 |
os.path.isabs() | 判断是否为绝对路径 |
os.path.normpath(path) | 规范path字符串形式 |
os.path.split(name) | 分隔文件名与目录(事实上,如果完全使用目录,它也会将最后一个目录作为文件名而使其分隔开,同时它不会判断文件或目是否存在) |
os.path.splitext() | 分离文件名和扩展名 |
os.path.join(path,name) | 连接目录与文件名或目录 |
os.path.basename(path) | 返回文件名 |
os.path.dirname(path) | 返回文件路径 |
os.path.split() | 返回一个路径下的目录名或文件名 |
os.path.isfile() | 检验给出的路径是否是一个文件 |
os.path.isdir() | 检验给出的路径是否是一个目录 |
os.path.existe() | 检验给出的路径是否真的存在 |
# 对文件路径的操作
import os
system = os.name
if system == 'nt':
print('当前的操作系统是Windows。')
else:
print('当前二点操作系统是Linux。')
print('本系统标识路径的分隔符是:' + os.sep)
print('本系统中使用的行终止符为:', [os.linesep])
path = os.getcwd() # 获得当前目录
print('运行本程序所在目录是:' + path)
print('计算机的Path环境变量如下图所示: \n' + os.getenv('Path'))
os.mkdir('test') # 创建空文件夹
print('当前文件夹中文件由: \n', os.listdir(path))
if os.path.exists('test'):
os.rmdir('test')
print('文件夹删除成功')
else:
print('文件夹不存哎')
print('删除后的结果为:\n', os.listdir(path))
filepath1 = 'Python7'
if os.path.isfile(filepath1):
print(filepath1 + '是一个文件。')
else:
print(filepath1 + '不是一个文件。')
name = 'Ch7.py'
print('本程序的大小为:', os.path.getsize(name))
name = os.path.abspath(name)
print('本程序的绝对路径是' + name)
print('本程序的文件名分别为:', os.path.split(name))
files = os.path.splitext(name)
print('本程序的扩展为:' + files[1])
print('本程序的文件名为:' + os.path.basename(name))
print('本程序的路径为 ' + os.path.dirname(name))
运行结果如下:
当前的操作系统是Windows。
本系统标识路径的分隔符是:\
本系统中使用的行终止符为: ['\r\n']
运行本程序所在目录是:D:\Python\PycharmProjects\7
计算机的Path环境变量如下图所示:
C:\ProgramData\Oracle\Java\javapath;C:\Program Files (x86)\Intel\iCLS Client\;C:\Program Files\Intel\iCLS Client\;C:\Windows\system32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Program Files (x86)\Intel\Intel(R) Management Engine Components\DAL;C:\Program Files\Intel\Intel(R) Management Engine Components\DAL;C:\Program Files (x86)\Intel\Intel(R) Management Engine Components\IPT;C:\Program Files\Intel\Intel(R) Management Engine Components\IPT;C:\Program Files (x86)\NVIDIA Corporation\PhysX\Common;C:\WINDOWS\system32;C:\WINDOWS;C:\WINDOWS\System32\Wbem;C:\WINDOWS\System32\WindowsPowerShell\v1.0\;C:\WINDOWS\System32\OpenSSH\;C:\Program Files\Intel\WiFi\bin\;C:\Program Files\Common Files\Intel\WirelessCommon\;C:\Program Files\dotnet\;C:\Program Files\Microsoft SQL Server\Client SDK\ODBC\170\Tools\Binn\;C:\studio\tools;C:\studio\platform-tools;C:\Program Files (x86)\Microsoft SQL Server\150\DTS\Binn\;C:\Program Files\MySQL\MySQL Utilities 1.6\;C:\Users\觉主有点迷\AppData\Local\Programs\Python\Python36\Scripts\;C:\Users\觉主有点迷\AppData\Local\Programs\Python\Python36\;C:\Users\觉主有点迷\AppData\Local\Microsoft\WindowsApps;;C:\Program Files (x86)\SSH Communications Security\SSH Secure Shell;D:\Bandizip\
os模块不仅提供了新建文件、删除文件、查看文件属性的操作功能,还提供了对文件路径的操作功能。但是,对于移动、复制、打包、压缩、解压文件及文件夹等操作,os模块没有提供相关的函数,此时需要用到shutil模块。
shutil模块是对os模块中文件操作的补充,是Python自带的关于文件、文件夹、压缩文件的高层次的操作工具、类似于高级API。
# 移动文件
import shutil
shutil.move('./text_file/e_point.txt', './data')
shutil.move('./text_file/e_point.txt', './data/point.txt') # 重命名
shutil.copytree函数用于进行目录的复制。该函数返回结果为复制后目录的路径。“程序”文件夹下的目录将复制到test文件夹内。需要注意的是,test文件夹必须事先不存在。
import shutil
# 复制文件
shutil.copyfile('Ch7.py', 'Ch7.py.copy')
# 跨路径复制文件
shutil.copy('./text_file/data.txt', './data/data.txt')
# 复制text_file文件夹下的目录到data1文件夹内
shutil.copytree('./text_file', './data1')
base_name | 压缩包 的文件名,也可以是压缩包的路径,是文件名时,则保存至当前目录,否则保存至指定路径 |
---|---|
format | 压缩包种类,可以是zip、tar、bztar、gztar |
root_dir | 要压缩的文件夹路径(默认当前目录) |
owner | 用户,默认当前用户 |
group | 组,默认当前组 |
logger | 用于记录日志,通常是logging.Logger对象 |
通过编写Python程序,将squares.csv文件及程序文件移动到当前工作目录下的test_file文件夹里,需要先把两个文件从把不同路径下复制到当前文件目录下的test_file文件夹里,然后直接调用函数将test_file文件夹压缩成RAR格式的压缩包。
import os
import shutil
file_name1 = './text_file/squares.csv' # csv文件
file_name2 = './test7.4.py' # 程序文件
out_file = os.getcwd() + '\\test' # 目标路径:当前工作目录+test文件夹
os.mkdir(out_file) # 创建文件夹
shutil.copy(file_name1, out_file) # 复制csv文件
shutil.copy(file_name2, out_file) # 复制程序文件
shutil.make_archive('test7.4', 'zip', root_dir=out_file) # 压缩文件