3.1注释
注释:单行注释，多行注释，批量注释，中文注释，特殊注释
3.1.1单行注释 #
#我是单行注释
>>>print("hello")
>>>print("hello") #我是单行注释3.1.2多行注释，批量注释
'''我是多行注释'''
"""我是批量注释"""3.1.3 中文注释。#
#coding=utf-8#
-*- coding:utf-8 -*-必须放在首部
3.1.4 特殊注释 #
#!/usr/bin/env python主要用于linux系统，用来告诉系统python解释器的位置
3.2标识符
组成是由字母数字下划线，不能以数字开头
大小写敏感区分
不能使用关键字，保留字
以双下划线开头的和结尾的表示特殊含义
3.3变量
3.3.1 通常声明和赋值
变量名=字面量或表达式
>x=5；分号可加可不加
>print(x)5>x=5；y=6；z=7多个变量分号区分
>print(y);
6
分号或者换行代表结束
>str="hello"
>print(str)
hello
>info="abcdefg"
>info
abcdefg文件的形式不可以省略print
3.3.2 链式赋值
变量1=变量2=字面量或表达式
等价于
变量2=字面量或表达式
变量1=变量2
3.4 复合赋值运算符(简洁表达式)
+=
-=
*=
/=
//=整除
num1=5;
num1+=1;
num1;
6定义过的变量可以反复使用
3.5删除变量
>del info
>info
报错3.6解包
>x,y=1,2(abc)
>x
1
>y2
(abc)前后个数一样，类型可以不一致
3.1常量
python里面没有常量
大写就表示常量
>>>NUM=5
3.2数据类型
分为内置数据类型，自定义数据类型
内置数据类型：数值数据类型，序列数据类型，集合数据类型，字典数据类型，特殊数据类型，其他数据类型
数值数据类型：整数，浮点数，布尔，复数
序列数据类型：字符串，元组，字节序列，列表，字节数组
集合数据类型：集，不可变集
3.2.1 整数(int)
利用进制表示整数
十进制
十六进制：0x(0X)
八进制：0o(0O)
二进制：0b(0B)
范例：
>>>i1=0b100
>>>i1
4
>>>type (i)
<class int>
3.2.2整数对象
>>>int (123)
123
>>>int("123")
123
>>>int("12a")
报错
int(x)
int (x,y)
>>>(123.78)
123
>>>('100',2)
4
>>>int (100,2)
报错
前面字符串，后面进制
单引号双引号均表示字符串
3.2.4float对象
前导0可以省略
>>>i2=.4
>>>i2
0.4
>>>type (3.14)
<class 'float'>
>>>float (124)
124.0
>>>float (3.14)
3.14
>>>float ('123')
123
>>>float ('abc')
报错
3.2.5复数类型
>>>1+2j
(1+2j)
>>>type(1+2j)
<class 'complex'>
实部虚部必须写，j不可以换成其他字母，实部虚部可以是整数或者浮点数
>>>1+j
报错
>>>j
报错
>>>1+2a
报错
>>>1+0j
(1+0j)
>>>0+1j
1j
>>>1+.5j
1+0.5j
>>>.+.j
报错
>>>1+.j
报错
>>>1+1.j
1+1j
不能前导0后导0同时省略
3.2.6 complex对象
complex(x,[y]) y可有可无
>>>c=complex(4,5)
>>>c
4+5j
>>>complex(6)
6+0j
>>>complex(7,)
7+0j
real：实部
imag：虚部
>>>(1+2j). real
1.0
>>>(1+2j).imag
2.0
>>>a=1+2j
>>>b=complex(4,5)
>>>a+b
5+7j
3.2.7布尔类型(bool)
布尔类型的值:True，False(首字母大写)
>>>True
True
>>>type(False)
<class 'bool'>
>>>type(true)
报错
3.2.8 bool对象
bool(x)
>>>bool(True)
True
>>>bool('True')
True
>>>bool(0)
False
>>>bool(1)
True
>>>bool('abc')
True
>>>bool('0')
True
>>>bool(0.0)
False
只要不是数值0，剩下都是True
3.3数据类型转换
显示转换，隐式转换
隐式转换(自动类型转换)
>>>1+23.4
24.4
>>>123+True
124
>>>123+False
123
显示转换(强制转换)
>>>int(123.4)
123
>>>i=3**2
>>>float(i)
9
>>>a=9999*9999
>>>float(i)
报错
能用隐式不要用显示，显示会形成精度丢失或者异常问题
3.4字符串(str)
字符串的表示有四种方式：
' ' , " "一行
''' ''' , "" ""跨行或多行
范例：字符串的拼接
>>>'abc'+'def'
'abcdef'
>>>'abc''def'
'abcdef'
3.5 转义字符
\n 换行
\r 回车
\t 一个水平制表符
\v 一个垂直制表符
\'
\"
\\
\f 换页
\b 退格
范例：
>>>s='a\tb\tc\td\t'
>>>s
'a\tb\tc\td\t'
>>>print (s)
a b c d
>>>s1=r'a\tb\tc\td\t'
>>>s1
'a\\tb\\tc\\td\\t'
>>>print(s)
'a\tb\tc\td\t'
把使用r或R的字符串称为原始字符，该字符串中包含的字符不能将进行转义
3.6str对象
str(x)
范例：
>>>str('abc')
'abc'
>>>str(1230)
'1230'
>>>str(True)
'True'
>>>str(2.12)
'2.12'
3.7运算符
1)算数运算符 + - * / % // **
2)比较运算符 == != > < >= <=
3)赋值运算符= += -= *= /= %= **= //=
//除法，取整（不四舍五入）
**幂运算
%取余
3.1
>>>a=10
>>>b=20
>>>a and b
20
>>>a or b
10
>>>not(a and b)
false
3.2成员运算符
In,not in
>>>x=abcde
>>>y=e
>>>z=you
>>>y in x
True
>>>z in y
False
>>>z not in x
True
3.3身份运算符
用于比较两个对象的存储单元
>>>x='abc'
>>>y=x
>>>z='abcde'
>>>x is y
True
>>>x is z
False
>>>x is not z
True
>>>x ='abc'
>>>y='abc'
>>>x is y
True
3.4括号运算符
()
3.5运算符优先级
逻辑型，not,and,or
测试型，is,not is,in,not in
关系型，== != > < >= <=
算数型，+,-,*,/,%,//
3.6 Q&A
问，is与==区别, is是地址比较，==是内容比较(与其他语言相反)
3.7异常
1)
print((3);print(x+'.'+y);
2)运行时错误或异常
primt(3);num1 +=1;print(5/0);
3)逻辑错误
求平均数，average=first+second/2;
正确的:average=(first+second)/2
我的手机 2018/10/14 18:19:15
3.8流程控制语句
分为顺序语句，判断语句(选择语句)，循环语句
3.8.1顺序语句
3.8.2选择语句
单分支
if(条件表达式):
语句
说明，
1)条件表达式：关系表达式，逻辑表达式，算数表达式
2)语句：可以是单个语句，也可以是多个语句，但如果是多个语句，要注意缩进
单个语句
>>>x=5
>>>y=6
>>>if(x>y)冒号没写
报错
多个语句
>>>x=1
>>>y=2
>>>if(x>y):
print('a')
else:
print('b')
b
>>>x=1
>>>y=2
>>>if(x>y):
print('a')
else:应该顶上
报错
>>>if(x>y):print('a')
else:print('b')
b
>>>if(x>y): print('a');else:print('b')
报错
无三元运算符
多分支
if(条件表达式):
语句
elif(条件表达式):
语句
…
else:
语句
if的嵌套
if(条件表达式):
语句
elif(条件表达式):
语句
…
else:
语句
范例:
计算两个数相处的结果，要除数为0时
3.8.3循环语句
循环分为for循环和while循环
名词解释:
1)可迭代对象:系列，字典，文件对象，迭代器对象，生成器对象
for循环的语法格式:
for 变量 in (对象集合):
>>>for i in (1,2,3,4,5):
print(i)
1
2
3
4
5
range对象:在Python3中，range对象表示一个迭代器对象，作用是用来产生指定的该迭代器数字序列
在Python2中，range它表示的是一个函数，为生成器。
range(start，stop，[step])
>>>for i in range(1,11,1):
print(i)
输出1—10
步长为一可以省略，开始数包含，终止数不包含，省略开始数时从0开始输出
>>>for i in range(10):
print(i，end=' ')
0 1 2…
>>>for i in range(10):
print(i，end='\t')
0 1 2…
while循环:
while(条件表达式):
语句
3.8.4循环的嵌套
范例：打印九九乘法表
for i in range (1,10):
for j in range(1,10):
print (i,'*',j,'=', i*j,end='\t')
print(' ')
嵌套不允许超过三层
3.8.5循环跳出
break，continue
3.8.6死循环
Ctrl+C：终止当前运行的程序
3.1 循环else语句
for，while循环语句中可以增加else子句。如果for，while循环没有被break终止，则会执行else子句，否则不循环。
for循环
for 变量 in 对象集合：
语句
else：
语句
While循环：
while（条件表达式）：
语句
else：
语句
haabbies=""
for i in range(1,3+1):
s=input("请输入爱好之一（最多三次，按Q结束）")
if s=='Q':
break
babbies+=s+' '
else:
print("你输入了三个爱好")
print("你的爱好为",habbies)
3.2空语句
for i in range(5):
if(i==3):
pass
print('执行')
print(i)
3.3练习
1)用户登录，三次机会
字符串连接最好不要用+号，最好用，号
username=admin
password=123456
for i in range(3):
user=input('请输入账号')
passwd=input('请输入密码')
if user ==username and passwd==password:
#print('登录成功，欢迎，admin，的登录')
print('登录成功，欢迎%s的登录'%(user))
break
eliif i==2
print('对不起，你输入出错次数已经是三次了')
else:
print('帐号与密码不匹配')
2)猜数字
生成随机数方法:
import random
s=random.randint(1,100)
print (s)
import random
s=random.randint(1,100)
print ('猜数字')
num=input('请输入你猜测的数字'\n)
guess=int (num)
n=0
while n<2:
if guess==answer and n==0:
print('你真厉害，一次就猜对了')
break
if guess<answer:
print('不对，太小了')
elif guess>answer:
print('不对，太大了')
elif guess=answer:
print('对了')
num=input('请输入你猜测的数字\n')
guess=int(num)
n=n+1
if n==1 and guess==answer
print('么么哒，你第二次猜对了')
break
elif n==2 and guess==answer
print('你终于第三次猜对了')
break
print('你太笨了，游戏结束')
3)输入若干个学生的成绩，求出平均值，最大值和最小值
sAvg=0
sCnt=1
sScore=int(input('请输入一个同学的成绩：(-1表示结束)')
sMax=sScore
sMin=sScore
while sScore>=0:
sAvg=sAvg+sScore
sCnt=sCnt+1
if sScore>sMax:
sMax=sScore
if sScore<sMin:
sMin=sScore
sScore=int(input('请输入一个同学的成绩：(-1表示结束)')
print('计算出来的平均成绩是'，sAvg／sCnt)
print('计算出来的最大成绩是'，sMax)
print('计算出来的最小成绩是'，sMin)
3.4数据结构
数据结构是用来存储和组织数据的方式，表示集合中的一种或多种特定关系
在Python中，常见的数据类型称为容器。序列(列表，元组)，映射(字典)，集合是三类主要的容器
3.5数组
数组都是一种数据结构，用来存储或者处理大量的数据。在数组中，通过索引下标进行访问操作
在Python中，没有数组这个东西。用系列数据类型来代替数组。
3.6系列数据类型
系列数据类型是python中最简单的数据结构，是一组有顺序的元素的集合。系列数据类型可以包含一个和多个元素，也可以包含空集合(没有元素)
系列数据类型包括：列表，元组，字符串，字节数据
3.7序列
序列的定义：把大量的数据按次序排列起来而形成的集合称为序列
所有的序列类型都可以进行某些特定的操作，这些操作包括：索引，分片，加，乘以及检查某个元素是否属于序列的成员，序列长度，最大元素，最小元素等操作
序列分类：按照顺序，有序序列，列表，元组，字符串
无序序列，字典，集合
按照序列内容变化，可变序列，列表，字典，集合
不可变序列，元组，字符串
3.8列表
列表是一组有序项目的数据结构。其中对象可以是任意类型，并不要求类型一致。
列表是数据类型，因此它可以进行添加，删除，修改等操作。
3.8.1列表的创建
字面量创建
对象创建
推导式创建
3.1列表
推导式:专门用来生成满足特定需求的列表
语法格式:
表达式 for 变量 in 序列
范例：
>>>list1=[x*x for x in range(1,10)]
>>>list1
[1,4,9,16,25,36,49,64,81]
>>>list2=[I for I in list1]
>>>list2
[1,4,9,16,25,36,49,64,81]
>>>list3=[I for I in list1 if i%2==0]
>>>list3
[4,16,36,64]
3.2列表的操作
列表的常见操作:索引访问，切片操作，连接操作，重复操作，成员关系操作，比较运算操作，以及求长度，最大值，最小值，求和等等。
3.2.1索引操作
下标只能是整数
>>>list1=[1,2,3,4]
>>>list1[0]
1
>>>list1[-1]
4
>>>list1[9]
index报错
>>>list1['a']
type错误
>>>list1[0]=10
>>>list1
[10,2,3,4]
3.2.2删除列表中的元素
>>>list1=[1,2,3,4]
>>>del list1[1]
>>>list1
[2,3,4]
3.2.3求列表的长度，最大值，最小值，求和
>>>list2=[1,2,3,4,5,6]
>>>len(list2)
6
>>>max(list2)
6
>>>min(list2)
1
>>>sum(list2)
21
注意：max，min，sum在使用时必须是列表中元素类型统一，sum只有是数值求和时才能用
3.2.4切片
截取列表的一部分
s[i:j]
s[i:j:k]
i开始下标，j结束下标，k步长，不包括j
ijk可以省略，格式不能省略
i省略表示从0开始，j省略表示到结尾结束，k省略表示步长为1
超边界不报错
范例：
>>>list5=[1,2,3,4,5,6,7]
>>>list5[1:3]
[2,3]
>>>list5
[1,2,3,4,5,6,7]
>>>list5[:3]
[1,2,3]
>>>list5[:2]=[]
>>>list5
[3,4,5,6,7]
>>>del list5[:1]
>>>list5
[4,5,6,7]
3.2.5连接和重复操作
连接+(只连接不去重)
重复*
>>>list6=[1,2]
>>>list7=[3,4]
>>>list6+list7
[1,2,3,4]
>>>list8=[1,2,3]
>>>list9=[3,4,5]
>>>list8+list9
[1,2,3,3,4,5]
>>>list10=[1,2,3]
>>>3*list10
[1,2,3,1,2,3,1,2,3]
3.2.6成员关系操作
in，not in，count()指定元素在列表中出现的次数，
index(x,[i,j])x指定元素，i开始位置j结束位置指定元素第一次出现的位置下标
>>>list1=[1,2,3,4,5]
>>>3 in list1
True
>>>list2=[1,2,3,3,4,5,3,3,5]
>>>list2.count(3)
4
>>>list2.index(5,5,8)
5
>>>list2.index(2)
1(省略ij，代表从头到尾)
>>>list2.index(9)
报错(如果不在直接报错)
3.2.7比较运算操作
>,>=,<,<=,==,!=逐个进行比较
范例：
>>>list1=['a','b']
>>>list2=['a','b']
>>>list3=['a','b','c']
>>>list4=['c','b','a']
>>>list1=list2
True
>>>
>>>list1<list3
True
>>>list4>list3
True
3.2.8排序操作
sorted()
>>>list5=[6,3,4,2,1]
>>>sorted(list5)
[1,2,3,4,6]
>>>list5
[6,3,4,2,1]
3.2.9 any，all
判断列表中的元素是否为true
>>>any([1,2,0])
True
>>>all([1,2,0])
False
3.2.10列表的遍历
>>>list1=['html','css','js']
>>>for i in list1:
print('序号:%s 值:%s '%(list1.index(i)+1,i))
序号：1 值： html
序号：2 值：css
序号：3 值：js
>>>for i in range(len(list1)):
print('序号:%s 值:%s'%(i+1,list1[i]))
3.2.11列表的拆封
>>>ab=[1,2]
>>>a，bc
报错
>>>a，b
(1,2)
>>>a
1
>>>b
2
>>>a，b，c=[1,2]
报错
>>> [1,2,3]
[1, 2, 3]
>>> temp=[1,2,3]
>>> temp
[1, 2, 3]
>>> data=[1001,'tom',[80,90,100]]
>>> sid,name,score=data
>>> name
'tom'
>>> sid
1001
>>> score
[80, 90, 100]
>>> sid,name,[chinese,english,math]=data
>>> chinese
80
>>> english
90
>>> math
100
>>> sid
1001
>>> name
'tom'
3.2.12列表的解析(推导式)
推导式:专门用来生成满足特定需求的列表
语法格式:
表达式 for 变量 in 序列
>>>list3=[I for I in list1 if i%2==0]
组表达式
>>>i=1
>>>[(i，i*2) for i in range(10)]
[(0,0,),(1,2),(2,4),(3,6),(4,8),(5,10),(6,12),(7,14),(8,16),(9,18)]
>>> x=1
>>> y=2
>>> z=3
>>> [(x,y,x+y+z) for x in range(1,4)]
[(1, 2, 6), (2, 2, 7), (3, 2, 8)]
>>> [(x,y,x+y+z) for x in range(1,4) for y in range(1,4) if x>=y]
[(1, 1, 5), (2, 1, 6), (2, 2, 7), (3, 1, 7), (3, 2, 8), (3, 3, 9)]
3.1 元组(定值表)
用来存储固定不变的值表，有序序列。
创建元组的方式：
1.字面量的方式
(x1,x2,,,)
x1,x2,,,,
范例：
>>>t1=(1,2,3,4,5)
>>>t1
(1,2,3,4,5)
>>>t2=1,2,3,4,5
>>>t2
(1,2,3,4,5)
>>>t3=()
>>>t3
()
>>>t4=1
>>>t4
1
>>>t4=1,
>>>t4
(1,)
若元组只有一个元素，需要在元素后加逗号
多个元素也可以加，加不加效果一样
2.对象
tuple()
>>>t7=tuple(1,2,3,4,5)
报错
>>>t7=tuple([1,2,3,4,5])
>>>t7
(1,2,3,4,5)
>>>t8=tuple("abcde")
>>>t8
("a","b","c","d","e")
>>>t2=(1,2,'a')
>>>t2
(1,2,'a')
元素可以不一样
>>>u=('abc')
>>>v=u,(1,2,3)
>>>v
(('a','b','c'),(1,2,3))
>>>v[1][1]=10
报错
元组本身不能变，但是因为类型不同可能会变
>>> a=tuple("abc")
>>> w=a,[1,2,3]
>>> w
(('a', 'b', 'c'), [1, 2, 3])
>>> w[1][1]=10
>>> w
(('a', 'b', 'c'), [1, 10, 3])
3.2元组的操作
与列表一样，索引访问，切片操作，连接操作，重复操作，成员关系操作，比较运算操作，求长度，最大值，最小值等等
>>>any((1,2,3))
True
>>>all((1,2,0))
False
>>> t=(1,2,3,4,5)
>>> for x in t:
print(x)
1
2
3
4
5
>>> for x in 3.13,5.12,6.77:
print(x)
3.13
5.12
6.77
>>> t1=(1,2)
>>> t2=(1,2)
>>> t3=(1,2,3)
>>> t1<t2
False
>>> t1<=t2
True
>>> t=(3,4,6,2,1)
>>> sorted(t)
[1, 2, 3, 4, 6]
>>> data=(1001,"张三",(100,90,89))
>>> sid,name,scores=data
>>> name
'张三'
>>> sid
1001
>>> scores
(100, 90, 89)
>>> sid,name,(chinese,math,english)=data
>>> chinese
100
>>> first,middle,last=(1,2,3,4,5,6,7,8,9)
Traceback (most recent call last):
File "<pyshell#29>", line 1, in <module>
first,middle,last=(1,2,3,4,5,6,7,8,9)
ValueError: too many values to unpack (expected 3)
>>> first,*middle,last=(1,2,3,4,5,6,7,8,9)
>>> first
1
>>> middle
[2, 3, 4, 5, 6, 7, 8]
>>> last
9
>>> *first,middle,last=(1,2,3,4,5,6,7,8,9)
>>> first
[1, 2, 3, 4, 5, 6, 7]
>>> middle
8
>>> last
9
*
去掉最高最低求均分
>>> first,*middle,last=sorted((67,56,87,23,45,90))
>>> sum(middle)/len(middle)
63.75
临时变量:_
>>>_,b_=(1,2,3)
>>>b
2
>>>_
3
>>>record=('tom','tom@163.com','0411-123456','123123123')
>>>name,_,*phones
>>>phones
['0411-123456','123123123']
>>>name，phones
('tom',['0411-123456','123123123'])
列表与元组相互转换
>>> t1=(1,2,3,4,5)
>>> list1=list(t1)
>>> list1
[1, 2, 3, 4, 5]
>>> list2=['a','b','c']
>>> t2=tuple(list2)
>>> t2
('a', 'b', 'c')
练习，输入一个数字，转换成中文数字
1234567890--->壹贰叁肆伍陆柒捌玖零
t1=('零','壹','贰','叁','肆','伍','陆','柒','捌','玖')
num=input('请输入数字'\n)
print(t1[int(num)])
方法一：
chinese_number=('零','壹','贰','叁','肆','伍','陆','柒','捌','玖')
number=input("请输入一个数字")
for i in number:
print(chinese_number[int(i)])
方法二：
chinese_number=('零','壹','贰','叁','肆','伍','陆','柒','捌','玖')
number=input("请输入一个数字")
dig_number=('0','1','2','3','4','5','6','7','8','9')
print(chinese_number[dig_number.index(number)])
方法三：
chinese_number=('零','壹','贰','叁','肆','伍','陆','柒','捌','玖')
number=input("请输入一个数字")
for i in range(len(number)):
if "." in number[i]:
print("点",end=" ")
else:
print(chinese_number[int(number[i])],end=" ")
字典
创建方式
1)字面量
>>>{'优':90,'良':80}
{'优':90,'良':80}
2)通过dict()方式
>>>dict1=dict([['优':90],['良':80],['中',70]])
>>>dict1
{'优':90,'良':80,'中':70}
把[]都换成()也可以
>>>dict3=dict(zip(['优','良','中'],[90,80,70]))
>>>dict3
{'优':90,'良':80,'中':70}
3)通过fromkeys()方式
4)推导式
键:值 for
>>> dict4={}.fromkeys(['优','良','中'],'大于60分')
>>> dict4
{'优': '大于60分', '良': '大于60分', '中': '大于60分'}
>>> dict5={}.fromkeys(['优','良','中'])
>>> dict5
{'优': None, '良': None, '中': None}
>>> dict6={}.fromkeys(['优','良','中'],None)
>>> dict6
{'优': None, '良': None, '中': None}
>>> dict7={n:n**2 for n in range(1,5)}
>>> dict7
{1: 1, 2: 4, 3: 9, 4: 16}
字典的操作
>>> dict3=dict(zip(['优','良','中'],[90,80,70]))
>>> dict3.get('优')
90
>>> dict3.get('差')
>>> dict3.get('差','键不存在')
'键不存在'
>>> dict3.get('优','键不存在')
90
>>> dict3['优']
90
items(),keys(),values()
>>> dict3.items()
dict_items([('优', 90), ('良', 80), ('中', 70)])
>>> dict3.keys()
dict_keys(['优', '良', '中'])
>>> dict3.values()
dict_values([90, 80, 70])
>>> for i in dict3.values():
print(i,end=",")
90,80,70,
>>> for i in dict3.items():
print(i,end=",")
('优', 90),('良', 80),('中', 70),
>>> for i in dict3.keys():
print(i,end=",")
优,良,中,
>>> for i in dict3:
print(i,end=",")
优,良,中,
合并字典update
>>> dict1={'No1':'Java','No2':'c','No3':'Python'}
>>> dict1
{'No1': 'Java', 'No2': 'c', 'No3': 'Python'}
>>> dict1['No4']='VB'
>>> dict1
{'No1': 'Java', 'No2': 'c', 'No3': 'Python', 'No4': 'VB'}
>>> dict1['No4']='php'
>>> dict1
{'No1': 'Java', 'No2': 'c', 'No3': 'Python', 'No4': 'php'}
>>> dict2={'No1':'Java'}
>>> dict3={'No2':'C','No3':'Python'}
>>> dict2.update(dict3)
>>> dict2
{'No1': 'Java', 'No2': 'C', 'No3': 'Python'}
>>> dict4={'No2':'c++'}
>>> dict2.update(dict4)
>>> dict2
{'No1': 'Java', 'No2': 'c++', 'No3': 'Python'}
删除元素
del(),pop(),popitem(),clear()
>>>del(dict2['No2'])
>>>dict2
{'No1:'Java','No3':'Python'}
>>>del dict2
>>>del2
报错
>>> dict5={'No1': 'Java', 'No2': 'c', 'No3': 'Python', 'No4': 'VB'}
>>> dict5.pop('No1')
'Java'
>>> dict5
{'No2': 'c', 'No3': 'Python', 'No4': 'VB'}
>>> dict5.pop('No1')
Traceback (most recent call last):
File "<pyshell#16>", line 1, in <module>
dict5.pop('No1')
KeyError: 'No1'
>>> dict5.pop('No1','键不存在')
'键不存在'
>>> dict5.popitem()
('No4', 'VB')
>>> dict5.popitem()
('No3', 'Python')
>>> dict5
{'No2': 'c'}
>>> dict5={'No1': 'Java', 'No2': 'c', 'No3': 'Python', 'No4': 'VB'}
>>> dict5.clear()
>>> dict5
{}
集合
创建方式:
1)字面量
{值}
值必须是固定的类型，字符串元组之类的，不可以是可变类型
>>>{1.2，True}
{True，1.2}
集合无序
>>>set1={'a',[1,2,3]}
报错
>>>set1={1,(1,2,3)}
不报错
2)通过对象创建 去重
set()参数最多是一个
frozenset()
范例：
>>> set1={'a',[1,2,3]}
Traceback (most recent call last):
File "<pyshell#0>", line 1, in <module>
set1={'a',[1,2,3]}
TypeError: unhashable type: 'list'
>>> set1={1,[1,2,3]}
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
set1={1,[1,2,3]}
TypeError: unhashable type: 'list'
>>> set1={1,(1,2,3)}
>>> set2=set('hello')
>>> set2
{'o', 'h', 'e', 'l'}
>>> set3=set([1,2,3,4,5])
>>> set3
{1, 2, 3, 4, 5}
>>> set4=set()
>>> set4
set()
>>> set5=set(1,2,3)
Traceback (most recent call last):
File "<pyshell#9>", line 1, in <module>
set5=set(1,2,3)
TypeError: set expected at most 1 arguments, got 3
3)推导式
>>> a=frozenset('hello')
>>> a
frozenset({'o', 'h', 'e', 'l'})
>>> {x*x for x in range(1,5)}
{16, 1, 4, 9}
>>> {1,True}
{1}
>>> {1,False}
{False, 1}
>>> {1,1.0}
{1}
3.3集合的操作
>>> set1={1,2,3,6,7,8,5,4,9}
>>> for i in set1:
print(i,end=',')
1,2,3,4,5,6,7,8,9,
>>> 1 in set1
True
>>> set1={1,2,3}
>>> set2={2,3,4,5,6}
>>> set1
{1, 2, 3}
>>> set1|set2
{1, 2, 3, 4, 5, 6}
>>> set1&set2
{2, 3}
>>> set1-set2
{1}
>>> set1^set2
{1, 4, 5, 6}
>>> set1.union(set2)
{1, 2, 3, 4, 5, 6}
>>> set1==set2
False
>>> set1>set2
False
>>> set1<set2
False
>>> set1
{1, 2, 3}
>>> len(set1)
3
>>> len(set2)
5
>>> max(set2)
6
>>>set1.update(set2)
{1,2,3,4,5,6}
>>>set1={1,2,3,4,5}
>>>set2=set1.copy()
>>>set2
{1,2,3,4,5}
>>>set2[0]
报错
因为集合的无序性，不可以做切片操作
>>> str1="字符串str的编码和解码操作"
>>> b1=str1.encode(encoding='cp936')
>>> b1
b'\xd7\xd6\xb7\xfb\xb4\xaestr\xb5\xc4\xb1\xe0\xc2\xeb\xba\xcd\xbd\xe2\xc2\xeb\xb2\xd9\xd7\xf7'
>>> b1.decode()
Traceback (most recent call last):
File "<pyshell#3>", line 1, in <module>
b1.decode()
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xd7 in position 0: invalid continuation byte
>>> b1.decode(encoding='cp936')
'字符串str的编码和解码操作'
>>> "结果为：%f"%88
'结果为：88.000000'
>>> '姓名：%s,年龄：%d,体重：%3.2f'%('张三',20,56)
'姓名：张三,年龄：20,体重：56.00'
>>> '%(lang)s has %(num)03d quote types.'%{'lang':'Python','num':2}
'Python has 002 quote types.'
>>> '{2},{1},{0}'.format('a','b','c')
'c,b,a'
>>> '{0},{1},{2}'.format('a','b','c')
'a,b,c'
>>> '{2},{1},{0}'.format('a','b')
Traceback (most recent call last):
File "<pyshell#10>", line 1, in <module>
'{2},{1},{0}'.format('a','b')
IndexError: tuple index out of range
3.1 函数的的定义和调用
使用def语句定义函数
def 函数名(参数列表):
函数体|语句
函数名全部为小写字母，可以用下划线(位置有要求，自定义函数位置放中间)
>>>def my_average(a,b):
return (a+b)/2
>>>my_average(1,2)
1.5
>>>def print_start(n):
print(("*"*n).center(50)) # center居中，宽度50
>>>print_start(5)
*****
练习:定义计算并返回第n阶调和数
(1+1/2+1/3+…1/n)
>>>def num(n):
tmt=0.0
for i in range(1,n+1): #取不到n+1
tmt=tmt+1.0/(i+1)
return tmt
不同数据类型占的内存大小不一样，但是需考虑涉及大量数据时。
3.2类
类的定义
类是一个数据结构
class 类名
类体
3.3对象的创建和调用
对象名=类名(参数列表)
对象.属性
对象.方法
>>>class Person:
def _init_(self, name,age):
self.name=name
self.age=age
>>>p=Person("Tom",45)
>>>p.name
Tom
>>>p.age
45
>>>class Person:
def _init_(self, name,age):
self.name=name
self.age=age
def say_hi(self):
print ("你好，我叫",self.name)
>>>p=Person ("Tom",45)
>>>p.say_hi()
你好，我叫Tom
定义里带self的叫方法，不带的叫函数
>>>class Car:
count=0
name="aodi"
>>>c=Car()
>>>c.name
"aodi"
>>>Car.name
"aodi"
>>>Car.count+=1
>>>Car.count
1
>>>class Person:
name="tom"
_age=34
>>>Person._age
报错
>>>Person.name
"tom"
>>>class Person:
name="tom"
_age=34
def get_info():
print (Person._age)
>>>p=Person ()
>>>p.get_info()
报错
>>>Person.get_info()
34
>>>p._Person__age
34
调用私有属性
对象._类名_ _属性
>>>class Person:
def _init_(self, name):
self._ _name=name
>>>p=Person ("tom")
>>>p.name
报错
>>>p.__name
报错
>>>p._Person__name
"tom"
Java：@overload 注解：补充或嵌入一些信息，代码运行
Python：装饰器
3.3 @property 装饰器
当作属性出现，而不是方法
属性装饰器 作用类似一个get方法
Property( getter , setter , delete , doc )
>>>class Person:
def _init_(self, name):
self._ _name=name
@property
def name(self):
return self.__name
>>>p=Person ("tom")
>>>p.name
"tom"
>>>class Person:
def _init_(self, name):
self._ _name=name
@property
def name(self):
return self.__name
@name.setter
def name(self, value):
self.__name=value
@name.deleter
def name(self):
del self.__name
删除的只能是非私有属性，私有属性不能删除。del __name报错
>>>p=Person ("tom")
>>>p.name='allen'
>>>print(p.name)
allen
>>>class Person:
def _init_(self, name):
self._ _name=name
def getname(self,name):
return self.__name
def setname(self, value):
self.__name=value
def delname(self):
del self.__name
name=property(getname，setname，delname，'我是name属性')
>>>p=Person ("tom")
>>>print(p.name)
tom
>>>p.name='allen'
>>>print(p.name)
allen
自定义属性
__getattr__
__getattribute__
__setattr__
__delattr__
>>>class C1:
pass
>>>o=C1()
>>>o.name='自定义'
>>>print(o.name)
自定义
>>>o.__dict__
{'name':'自定义'}
公有属性
str.upper(object.__getattribute__(self,name))
def __setattr__(self,name,value):
>>>class Person:
def _init_(self):
pass
def __getattribute__(self,name):
return object.__setattr__(self,name,atr.strip(value))
>>>o=Person('tom')
>>>
>>>
方法:
实例方法
(对象传参的时候不需要给self
传第一个参数必须是self的方法称为实例方法)
def 方法名称 (self,[参数列表]):
静态方法
不能对特定的实例进行操作
@staticmethod
def 方法名称([参数列表])
静态方法可以直接用类名调用
类方法
不对特定实例进行操作
@classmethod
@classmethod
def 方法名称 (cls，[参数列表]): cls无需传参，用类名调用
>>> class Foo:
classname='Foo'
def __init__(self,name):
self.name=name
def f1(self):
print(self.name)
@staticmethod
def f2():
print('static')
@classmethod
def f3(cls):
print(cls.classname)
>>> f=Foo('中')
>>> f.f1()
中
>>> Foo.f2()
static
>>> Foo.f3()
Foo
以两个下划线开头的但是不以两个下划线结尾的是私有方法
以两个下划线开头，结尾的是内置方法
>>> class Methods:
def publicMethod(self):
print('公有方法')
def __privateMethod(self):
print('私有方法')
def publicMethod2(self):
self.__privateMethod()
>>> m=Methods()
>>> m.publicMethod()
公有方法
>>> m._Methods__privateMethod()
私有方法
>>> m.publicMethod2()
私有方法
对象调用，self无需传参，但是
如果以类名调用时必须传参，传的参数必须是对象
>>>Methods.publicMethod(m)
公有方法
>>>Methods.__Methods__privateMethod(m)
私有方法
方法重载。 有争议
最后一个函数把前一个函数覆盖
>>> class Person:
def say_hi(self,name):
print('你好，我叫',self.name)
def say_hi(self,name,age):
print('你好，我叫{0},年龄{1}'.format(name,age))
>>> p=Person()
>>> p.say_hi('tom',23)
你好，我叫tom,年龄23
>>> p.say_hi('allen')
Traceback (most recent call last):
File "<pyshell#21>", line 1, in <module>
p.say_hi('allen')
TypeError: say_hi() missing 1 required positional argument: 'age'
继承
继承是多继承
class 子类(父类1,父类2…)
子类=派生类，父类=基类
范例：
class Foo：
class Foo(object)：
继承
继承是多继承
class 子类(父类1,父类2…)
子类=派生类，父类=基类
所有类的父类是object
范例：
class Foo：
class Foo(object)：
多个父类时建议使用，只有一个时不建议
>>>class Person:
def __init__(self, name,age):
self.name=name
self.age=age
def say_hi(self)：
print("你好，我叫{0}，年龄{1}".format(self.name,self.age))
>>>class student(Person)：
def __init__(self, name,age,stu_id):
Person.def _init_(self, name,age)
self.stu_id=stu_id
def say_hello(self)：
Person.say_hi(self)
print("我是学生，我的序学号是",self.stu_id)
一个父类时
>>>class Person:
def __init__(self, name,age):
self.name=name
self.age=age
def say_hi(self)：
print("你好，我叫{0}，年龄{1}".format(self.name,self.age))
>>>class student(Person)：
def __init__(self, name,age,stu_id):
super(Person,self).__init__(name,age)
self.stu_id=stu_id
def say_hello(self)：
super(Person,self).say_hi()
print("我是学生，我的序学号是",self.stu_id)
查看类的继承关系
mro(),__mro__
>>> class A:
pass
>>> class B(A):
pass
>>> class C(B):
pass
>>> class D(A):
pass
>>> class E(B,D):
pass
>>> D.mro()
[<class '__main__.D'>, <class '__main__.A'>, <class 'object'>]
>>> E.__mro__
(<class '__main__.E'>, <class '__main__.B'>, <class '__main__.D'>, <class '__main__.A'>, <class 'object'>)
>>> class Dimension:
def __init__(self,x,y):
self.x=x
self.y=y
def area(self):
pass
>>> class Circle(Dimension):
def __init__(self,r):
Dimension.__init__(self,r,0)
def area(self):
return 3.14*self.x*self.x
>>> class Rectangle(Dimension):
def __init__(self,w,h):
Dimension.__init__(self,w,h)
def area(self):
return self.x*self.y
>>> d1=Circle(2.0)
>>> d2=Rectangle(2.0,4.0)
>>> print(d1.area())
12.56
>>> print(d2.area())
8.0
>>> class Dimension:
def __init__(self,x,y):
self.x=x
self.y=y
def area(self):
pass
>>> class Circle(Dimension):
def __init__(self,r):
Dimension.__init__(self,r,0)
def __area(self):
return 3.14*self.x*self.x
>>> d=Circle(2.0)
>>> print(d.area())
None
>>> d1=Dimension(2.0,4.0)
>>> print(d1.area())
None
多态
表现，方法的重载与重写，运算符的重载
特殊方法，一个是用来输出，一个是运算符重载
print默认调用__str__
>>> class Person:
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self):
return "{0},{1}".format(self.name,self.age)
>>> p=Person('tom',23)
>>> print(p)
tom,23
__add__等价于+
>>> x=1
>>> y=2
>>> x+y
3
>>> class Mylist:
def __init__(self,x,y):
self.x=x
self.y=y
def __add__(self):
for i in range(1,4):
print(i)
文件的分类：
1>文本文件
文本文件的操作
1)打开文件
2)操作
3)关闭
ascell码文件，默认编码格式为Unicode
打开文件时，状态为只读模式
open(文件,模式)
open('data1.txt','w')写，存在不报错
open('data2.txt','x')创建文件，存在即报错
open('data3.txt','a')附加模式
写操作
write()把字符串写进(对象不同)
writelines()把列表写进(对象不同)不换行 \n换行
flush()
关闭
close()可以不写
Python语句使用with语句，自动关闭并释放资源
with open('data1.txt','w')as f：
2>二进制文件
文件的操作：
open()
write()
read()
close()
f. close()
利用with语句进行辅助工作，它的特点是会系统自动关闭然后释放资源
with open(路径,模式) as f:
f:对象的名字
写的方法：
write（）写字符串
writelines（） 写列表
读的方法：
read（）从头到尾，返回字符串
readlines（）读取多行返回列表
readline（）读取一行
>>> with open('d:\data1.txt','w') as f:
f.write('123\n')
f.write('456\n')
f.writelines(['abc\n','def\n'])
4
4
>>> f=open('d:\data1.txt','r')
>>> f.readline()
'123\n'
>>> f.read()
'456\nabc\ndef\n'
>>> f.readlines()
[]
>>> f=open('d:\data1.txt','r')
>>> f.readline()
'123\n'
>>> f.readlines()
['456\n', 'abc\n', 'def\n']
>>> f.close()
>>>
>>> with open('d:\data1.txt','r')as f:
for s in f.readlines():
print(s,end=' ')
123
456
abc
def
>>> import sys
>>> sys.getdefaultencoding()
'utf-8
>>> with open(r'd:\data1.txt','r',encoding='utf-8')as f:
# r原始字符串，避免转义操作
#最好加上编码集
open(file, mode, buffering, encoding, errors, newlines, closed, opener)
utf-8==utf8
>>> with open('d:\data2.txt','wb') as f: # wb 写二进制文件
f.write(b'123\n') # b 区分是二进制文件
4
>>> with open(r'd:\data2.txt','rb')as f:
b=f.read()
print(b)
b'123\n'
>>> with open('d:\data3.txt','w+b') as f: # w+b 随机文件
f.write(b'123\n')
4
>>> with open('d:\data3.txt','r+b') as f:
b=f.read()
print(b)
b'123\n'
>>>
内存文件的操作
在内存中创建临时文件并进行内存的苏区操作
在Python标准库中的IO模块里提供了两个对象来实现文件的读写操作。
StringIO()和BytesIO()
>>> from io import StringIO
>>> f=StringIO('hello\nhi\nGoodBye\n')
>>> for s in f:
print(s)
hello
hi
GoodBye
>>> from io import BytesIO
>>> f=BytesIO('中国')
Traceback (most recent call last):
File "<pyshell#1>", line 1, in <module>
f=BytesIO('中国')
TypeError: a bytes-like object is required, not 'str'
>>> f=BytesIO(b'中国'.encoding('utf-8'))
SyntaxError: bytes can only contain ASCII literal characters.
>>> from io import BytesIO
>>> f=BytesIO()
>>> f.write('中国'.encoding('utf-8'))
6
>>>s=f. read()
>>>print(s)
b''
>>>f. seek(0)
0
>>>s=f. read()
>>>print(s)
b'\xe4\xb8\xad\xe5\x9b\xbd
>>>print(f. getvalue())
b'\xe4\xb8\xad\xe5\x9b\xbd
Python标准库
中包含下列文件处理的相关模块
Io模块：文件流的输入输出操作模块
bz2模块：读取和写入基于bzip2压缩算法的压缩文件
gzip模块：读取和写入基于gzip压缩算法的压缩文件
zipfile模块：读取和写入基于zip压缩算法的压缩文件
zlib模块：读取和写入基于zlib压缩算法的压缩文件
tarfile模块：读取和写入基于tar格式的卷文件（支持压缩和非压缩）
glob模块：查找符合特定规则的文件路径名
fnmatch模块：使用模式来匹配文件路径名
fileinput模块：处理一个或多个输入文件
filecmp模块：用于文件的比较
csv模块：读取和写入csv格式的文件（excel导入和导出格式）
pickle和cpickle：序列号Python对象
xml包：XML核心处理操作
os模块：基本操作系统功能，包括文件操作
import sys,gzip
filename=sys.argv[0]
filenamezip=filename+'.gz'
with gzip.open(filenamezip,'wt')as f:
for s in open(filename,'r'):
f.write(s)
for s in gzip.open(filename,'r'):
print(s)
csv：逗号分隔符文本格式。用来Excel和数据库进行数据的导入和导出操作。数据间逗号必须是英文逗号
学号,姓名,性别,班级,语文,数学,英语
20180101,张三,男,一班,90,78,98
20180102,李四,女,二班,89,99,67
Csv(逗号分隔符).csv
与创建文本文档改扩展名导致的结果不同
如果是读数据，需要使用的是csv.reader对象 dictreader()
如果是写入数据,则需要使用的是csv.writer对象 dictwriter()
import csv
def readcsv1(csvfilepath):
with open(csvfilepath,newline='') as f:
f_csv=csv.reader(f)
headers=next(f_csv)
print(heaers)
for row in f_csv:
print(row)
if __name__=='__main__':
readcsv(r'd:\scores.csv')
writerow():写入一行数据
writerows():写入多行数据
dialect:只读
import csv
def readcsv1(csvfilepath):
with open(csvfilepath,newline='') as f:
f_csv=csv.reader(f)
headers=next(f_csv)
print(heaers)
for row in f_csv:
print(row)
if __name__=='__main__':
readcsv(r'd:\scores.csv')
import csv
def writecsv1(csvfilepath):
headers=['学号','姓名','性别','班级','语文','数学','英语']
rows=[('20180101','张三','男','软件一班','90','89','87'),
('20180102','李斯','女','软件二班','91','79','86'),
('20180103','王五','男','软件三班','92','99','85')]
with open(csvfilepath,'w',newline='') as f:
f_csv=csv.writer(f)
f_csv.writerro(headers)
f_csv.writerrow(rows)
if __name__=='__main__':
writecsv1(r'd:\scores.csv')
对象序列化（系列化，串行化）
pickle cpickle
必须进行加密，否则可以才出来内容
序列化：
import pickle
with open(r'd:\bd\dataObject.dat','wb')as f:
s1='hello'
s2=1+2j
s3=(1,2,3)
s4=dict([['name':Mary],['age':24]])
pick.dump(s1,f)
pick.dump(s2,f)
pick.dump(s3,f)
pick.dump(s4,f)
反序列化：
import pickle
with open(r'd:\bd\dataObject.dat','rb')as f:
o1=pickle.load(f)
o2=pickle.load(f)
o3=pickle.load(f)
o4=pickle.load(f)
print(type(o1),str(o1))
print(type(o2),str(o2))
print(type(o3),str(o3))
print(type(o4),str(o4))
文件夹的创建与删除
remove()：删除文件
exists()：判断文件或者文件夹是否存在
Path：路径
import os
filename='d:\data2.txt'
isExits=os.path.exits(filename)
if isExits:
os.remove(filename)
print('文件已删除成功')
else:
print('要删除的文件不存在')
mkdir():创建一级文件夹
Makedirs():创建多级文件夹
import os
dirname=r'd:\pythontest'
multipledirname=r'd:pythontest1\program\test'
isExits=os.path.exits(dirname)
if isExits:
print(dirname,'文件夹已存在')
else:
os.mkdir(dirname)
print('已经成功创建了一个文件夹')
isExits=os.path.exits(multipledirname)
if isExits:
print(multipledirname,'文件夹已存在')
else:
os.makedirs(multipledirname)
print('已经成功创建了一个文件夹')
Rmdir():只能删除空文件夹
如果想要删除非空文件夹，那么需要使用shutil中的rmtree（）
import os
import shutil
dirname=r'd:\pythontest'
multipledirname=r'd:pythontest1\program\test'
isExits=os.path.exits(dirname)
if isExits:
os.rmdir(dirname)
print('成功删除文件夹')
else:
print('要删除的文件夹不存在')
isExits=os.path.exits(multipledirname)
if isExits:
shutil.rmtree(multipledirname)
print('成功删除文件夹')
else:
print('要删除的文件夹不存在')
批量创建文件夹
import os,sys
def genDir():
base=r'd:/bd/train/train1/' # 多级文件夹采用反斜杠
i=1
for j in range(100):
file_name=base+str(i)
os.mkdir(file_name)
i=i+1
if __name__=='__main__':
genDir()
创建指定名字的文件夹
Listdir():返回指定目录下的所有文件或文文件夹
import os,sys
path1=r'c:\101test'
path2=r'd:/bd/train/train1/'
def mkDir():
------没抄下来
dirs = os.listdir(path1);
for dir in diers:
file_name = path2 +dir
os.mkdir(file_name)
if __name__=='__main__':
mkDir()
根据指定路径的文件夹内容创建文件夹
import os
bathpath=r'd:/bd/train/train1/'
for line in open(r'c:/101test/ab.txt'):
basename=line.strip()
folder=os.path.join(basepath,basename)
filename=os.path.join(folder,basename)
os.mkdir(folder)
open(filename,'w').close()
扫一扫
4335
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
