lst_1 = [1, 2, 3]
lst_2 = [4]
lst_3 = [[1, 2, 3], [4, 5, 6]]
lst_mix = [160612, "张明", 18, [92, 76, 85]]
lst_empty = []
>>>tup_1 = (1, 2, 3)
>>>tup_empty = ()#这是一个空的元组
>>>tup_empty
()
>>>t1 = (1)#写成这种形式会产生歧义,因为小括号既可以表示元组也可以表示数学运算中的小括号,因此Python规定,这种形式按照小括号进行计算,计算结果为1
>>>t2 = (1,)#如果想表示为元组,需要在后面加上一个,逗号,表示元组
>>>print("t1 = ",t1,type(t1))
t1 = 1 <class 'int'>
>>>print("t2 = ",t2, type(t2))
t2 = (1,) <class 'tuple'>
索引是有方向的
-6,-5,-4,-3,-2,-1 逆向索引
P y t h o n
0 1 2 3 4 5 正向索引
示例
# 字符串索引
>>>str py = "Python"
>>>print(str_py[0])
p
>>>print(str_py[-1])
n
对于列表也是一样的
# 列表索引
>>>1st = [1, 2, 3]
>>>print(1st_1[1])
2
>>>print(1st_1[-2])
2
例如:
# 字符串切片
>>>str_py = Python"
>>>print(str_py(1:5))
'ytho'
>>>print(str_py[1:])
'ython'
>>>print(str_py[:5])
'Pytho'
列表的切片也是一样的
# 列表切片
>>>list1 = [1, 2, 3]
>>>list1[2:]
[3]
print(序列数据结构名称) 输出整个序列
>>>1st_1 = [1, 2, 3]
>>>print(1st_1)
[1, 2, 3] #打印整个列表
>>>tup_1 = (1, 2, 3)
>>>print(tup_1)
(1, 2, 3) #打印整个元组
>>>print(1st_1[0]) #打印列表中的元素
1
#获取字符串的长度
>>>len("Python")
6
>>>str = "Python"
>>>len(str)
6
#获取一维列表的长度
>>>1st_1 = [1, 2, 3]
>>>len(1st_1)
3
#获取二维列表的长度
>>>1st_3 = [[1,2,3],[4,5,6]]#是两个一维元素的二维列表
>>>len(1st_3)
2
#获取混合列表的长度
>>>1st_mix = [160612, "张明", 18, [92, 76, 85]]
>>>len(1st_mix)
4
#获取元组的长度
>>>tup_1 = (1, 2, 3)
>>>len(tup_1)
3
# 向列表中追加元素
>>>1st_1 = [1, 2, 3]
>>>1st_1.append(4)
>>>1st_1
[1, 2, 3, 4]
第一个参数是指定位置x,在第x个位置后面插入元素
第二个元素是要插入的元素
#向列表中追加元素
>>>1st_1 = [1, 2, 3]
>>>1st_1.insert(1,5)
[1, 5, 2, 3]
#合并列表
>>>1st_1 = [1, 2, 3]
>>>1st_2 = [4]
>>>1st_1.extend(1st_2)
>>>1st_1
[1,2,3,4]
>>>1st_1 = [1,2,3]
>>>1st_2 = [4]
>>>1st_3 = 1st_1 + 1st_2
>>>1st_3
[1,2,3,4]
>>>lst_1 = [1,2,3,4]
>>>del lst_1[1]# 删除下标为1的元素
>>>lst_1
[1,3,4]
>>>lst_1 = [2,3,1,4]
>>>lst_1.sort()#将lst_1中的元素按从小到大的顺序排列
>>>lst_1
[1,2,3,4]
>>>lst_1.reverse() #将lst_1中的元素原地逆序
>>>lst_1
[4,3,2,1]
由于元组一经定义之后就不能更改,因此元组不支持更新操作
#遍历列表中的元素
>>>lst_1 = [1,2,3,4]
>>>for i in lst_1:
print(i, end=" ")
1 2 3 4
{键:值, 键:值, 键:值, …}
键:数字/字符串
值:任意Python对象/数据类型
>>>dic_score = {
"语文":80, "数学":85, "英语":78, "体育":90}#字符串关键字为键,数字为值
>>>dic_employ = {
"name":"Mary", "age":26}
>>>dic_employ = {
"name":{
"first":"Mary", "last":"Smith"}, "age":26}#字典支持嵌套定义
>>>dic_score = {
"语文":80, "数学":85, "英语":78, "体育":90}
>>>print(dic_score)
{
"语文":80, "数学":85, "英语":78, "体育":90}
>>>print(dic_score["语文"])
80
>>>len(dic_score)#使用len()函数可以得到字典的长度
4
>>>dic_student = {
'name':'张明', 'sex':'男', 'age':18, 'score':98}
>>>'sex' in dic_student
True
例子:遍历字典中所有的键
>>>dic_student = {
'name':'张明', 'sex':'男', 'age':18, 'score':98}
>>>for key in dic_student.keys():
print(key, end=" ")
age name score sex
字典中各个元素是无序的,所有每次打印出来的结果可能是不同的
例子:遍历字典中所有的键对值
>>>dic_student = {
'name':'张明', 'sex':'男', 'age':18, 'score':98}
>>>for item in dic_student.items():
print(item)#没有设置end参数,默认为换行符,每次输出都换行
('age',18)
('name','张明')
('score',98)
('sex','男')
>>>dic_student = {
'name':'张明', 'sex':'男', 'age':18, 'score':98}
>>>for key,val in dic_student.items():
print("dic_student[%s] = "%(key), val) #%s输出变量key,然后输出第二项val
dic_student[name] = 张明
dic_student[sex] = 男
dic_student[age] = 18
dic_student[score] = 98
可以通过赋值语句向字典中添加一个字典元素,修改指定元素的取值
>>>dic_student = {
'name':'张明','sex':'男','age':18}
>>>dic_student['score'] = 98
>>>print(dic_student)
{
'name':'张明','sex':'男','age':18,'score': 98}
>>>dic_student['score'] = 90
>>>print(dic_student)
{
'name':'张明','sex':'男','age':18,'score': 90}
将另一个字典的元素追加到字典中
>>>dic_student = {
'name':'张明','sex':'男','age':18}
>>>dic_contact = {
'tel':13104415887,'email':'[email protected]'}
>>>dic_student.update(dic_contact)
>>>print(dic_student)
{
'name':'张明','sex':'男','age':18,'tel':13104415887,'email':'[email protected]'}
>>>dic_student = {
'name':'张明','sex':'男','age':18}
>>>dic_student.pop('sex')
>>>print(dic_student)
{
'name':'张明','age':18}
>>>dic_student.clear()
>>>print(dic_student)
{
}
集合(set):由一组无序排列的元素组成
>>>set1 = {
1,2,3,4,5,4,5}
>>>print(set1)
{
1,2,3,4,5}# 输出的集合中重复的元素被清除了
>>>len(set1)
5
>>>set_2 = set("Python")
>>>print(set_2)
{
'P','y','t','h','o','n'}#在集合中是无序的
>>>set_3 = frozenset("Python")
>>>print(set_3)
frozenset({
'P','y','t','h','o','n'})
集合中的元素是无序的,因此不能像通过下标来访问,但是不知道为啥这里是有序的。
打印集合、获取集合长度、遍历集合
直接加载,任何时候都可以直接调用
Python3.6.2版本,一共提供了68个内置函数
取绝对值函数
幂函数
四舍五入函数
除法取余函数
函数 | 原型 | 具体说明 |
---|---|---|
abs() | abs(x) | 返回x的绝对值 |
pow() | pow(x,y) | 返回x的y次幂 |
round() | round(x[, n]) | 返回浮点数x的四舍五入值,参数n指定保留的小数位数,默认为0 |
divmod() | divmod(a,b) | 返回a除以b的商和余数,返回一个元组,divmod(a,b)返回(a/b,a%b) |
>>>abs(-1)
1
>>>pow(2,3)
8
>>>round(3.1415,2)
3.14
>>>round(3.54)
4
>>>divmod(5,3)
(1,2)
函数 | 描述 | 函数 | 描述 |
---|---|---|---|
len() | 返回长度 | list() | 转换为列表 |
max() | 返回最大值 | help() | 显示帮助信息 |
sum() | 返回总和 | dir() | 显示属性 |
str() | 转换成字符串 | type() | 显示类型 |
float() | 转换为浮点数 | range() | 返回一个整型列表 |
int() | 转换为整型表示 | open() | 打开 |
定义函数:函数名、参数和返回值
def 函数名(参数列表):
函数体
参数列表中是形式参数/形参,可以为空,多个话用逗号分隔
例如:
def add(a, b):
c = a + b
return c
返回值可以是任何形式的参数,返回值可以是多个值
def add_mul(a, b):
add=a+b
mul=a*b
return add,mul
也可以没有返回值
def say_hello(your_name):
print("Hello,%s!"%your_name)
函数名(参数列表)
这里的参数列表是实际参数,即实参,实参的个数、类型要与形参一一对应,并且需要由确认的值。
def add(a, b):
c = a + b
return c
>>>add(1,2)
3
通过多元赋值语句,通过获取多个返回值
def add_mul(a, b):#定义函数
add=a+b
mul=a*b
return add,mul
>>>x,y = add_mul(1,2)#调用函数
>>>print("add:",x,";mul:",y)
add:3;mul:2
调用函数时必须要有函数名后面的小括号,即使没有参数也要有
def say_hello(your_name):
print("Hello,%s!"%your_name)
>>>say_hello()
Hello!
def setNumber():
a=9
a=a+1
print("setNumber:",a)
>>>setNumber()
setNumber:10
>>>print(a)
NameError: name 'a' is not defined
再看,
a = 100 #定义全局变量
def setNumber():# 定义函数
a=9# 定义局部变量
a=a+1
print("setNumber:",a)#打印局部变量
setNumber()#调用函数,打印局部变量
print(a)#打印全局变量
#输出结果为
setNumber: 10
100
可以为参数指定默认值,函数内部没有定义该函数的话就取它的默认值
def 函数名(参数1=默认值,参数2=默认值...)
函数体
例如
def add(a,b=2):
return a+b
print(add(1))#a取值1,b取值默认值2
print(add(2,3))#都设置了值,那么就不取默认值
运行结果:
3
5
当函数有多个默认值时,参数的默认值只能从右往左依次设置,否则将报错
def add(a, b=1, c=2):#正确的
return a+b+c
def add(a=1, b, c=2):#会报错
return a+b+c
def add(a=1, b=2, c):#会报错
return a+b+c
def sum(list):
sum=0
for x in list:
sum+=x
return sum
>>>lst_1 = [1,2,3,4,5]
>>>print(sum(lst_1))
15
import 名称 [as 别名]
例如
import numpy as np# 导入numpy函数库,并为它起一个名别np
np.random.random()# 调用numpy库中的random类中的random()函数
from 模块/包名称 import 函数名 as 函数别名
from numpy import *# *表示导入numpy函数中的所有函数
random.random()#下面可以直接使用numpy库中的random类,无需库 的名称或者别名作为前缀,但是为了避免混淆,所以最好不要省略
推荐使用第一种导入整个包的方式,因为标准库的random.random()和numpy库中的random.random()不一样
一般在导入库的时候,一般按照这样的顺序:
python 标准库/模块
python 第三方库/模块
自定义模块
模块/包/库名.函数名(参数列表)
模块/包/库名.变量名
例如
>>>import math# 导入math模块
>>>math.pow(2,3)# 计算2的3次幂
8.0
>>>from math import pow, aqrt # 从math的模块中只导入pow和sqrt函数
>>>pow(2,3)
8.0
>>>sqrt(16)
4.0
>>>from math import sqrt as s# 从math模块中导入sqrt函数并重命名为s
>>>s(16)
4.0
def print_str(str):#打印字符串
print(str)
def sum(a,b):
return a+b# 求和
>>>import mymodeule as mm# 导入mymodule模块
>>>mm.print_str("Python")# 调用打印函数
Python
>>>mm.sum(2,3)# 调用求和函数
5
变量 | 功能 |
---|---|
sys.platform | 获取当前操作系统 |
sys.path | 获取指定模块搜索路径 |
sys.path.append() | 添加指定模块搜索路径 |
sys.argv | 获取当前正在运行的命令行参数的参数列表 |
sys.exit(n) | 退出应用程序,n=0,正在退出;n=1,异常退出 |
sys.getdefaultencoding() | 获取系统当前编码 |
sys.setdefaultencoding() | 设置系统默认编码 |
sys.getfilesystemencoding() | 获取文件系统使用编码方式,Windows下返回‘mbcs’,mac下返回‘utf-8’ |
>>>import sys
>>>sys.platform
win32
>>>sys.path
...
...
>>>sys.path.append('F:\\myPrograme')#sys.path.append('路径')
获取操作系统的详细信息和与Python有关的信息
函数 | 功能 |
---|---|
plaform.patform() | 获取操作系统名及版本信息 |
platform.system() | 获取操作系统类型 |
platform.version() | 获取操作系统的版本信息 |
platform.procession() | 获取计算机的处理器信息 |
platform.python_build() | 获取Python的版本信息,包括Pyhton的主版本,编译版本号和编译时间等信息 |
变量和函数 | 功能 |
---|---|
math.e | 返回自然对数e的值 |
math.pi | 返回Π的值 |
math.exp(x) | 返回e的x次幂 |
math.fabs(x) | 返回x的绝对值 |
math.cell(x) | 返回大于等于x的最小整数 |
math.floor(x) | 返回小于等于x的最大整数 |
math.log(x,s) | 返回loga(x),如果不指定参数a,则默认使用e |
math.log10(x) | 返回log10(x) |
math.pow(x,y) | 返回x的y次幂 |
math.sqrt(x) | 返回x的开平方 |
random模块:生成随机数
函数 | 功能 |
---|---|
random.random() | 生成一个0到1的随机浮点数 |
random.uniform(a,b) | 生成一个指定范围内的随机浮点数。其中a是下限,b是上限 |
random.randint(a,b) | 生成一个指定范围内的随机整数。a是下限,b是上限 |
random.choice(seq) | 从序列中随机获取一个元素。参数seq表示一个有序类型,可以是一个列表、元组或者字符串 |
random.shuffle(x) | 将一个列表x中的元素打乱 |
函数、模块、包和库之间有什么区别和联系?我们使用的tensorflow是哪个级别?
类(class):具有相同的属性和方法的对象集合
说明这个类有哪些属性和方法
class 类名:
类属性 = 初值
方法(参数列表)
类属性 | 含义 |
---|---|
__name__ | 类的名字(字符串) |
__doc__ | 类的文档字符串 |
__bases__ | 类的所有父类组成的元组 |
__dict__ | 类的属性组成的字典 |
__module__ | 类所属的模块 |
__class__ | 类对象的类型 |
class Preson:#一般类名的首字母大写
money = 10000
def say_hello(self):
print("Hello!")
对象名 = 类名()
例子
class Preson:#一般类名的首字母大写
money = 10000
def say_hello(self):
print("Hello!")
zhangsan = Preson()
print(zhangsan.money)
zhangsan.say_hello()
输出结果为:
10000
Hello!
但是这些属性只属于这个对象
class Preson:#一般类名的首字母大写
money = 10000
def say_hello(self):
print("Hello!")
zhangsan = Preson()
zhangsan.major = "computer"
print("zhangsan's major is",zhangsan.major)
输出结果为
zhangsan's major is computer
del 对象名
del zhangsan# zhangsan对象就不存在了,再次访问就会出错
__init__(self,参数2,参数3,...)
__del__()
下面看一个使用构造函数和析构函数的例子:
class Person:
def __init__(self,name,age,gender="男"):
self.name = name
self.age = age
self.gender = gender
def __del__(self):
print("Bye bye--from",self.name)
def printInfo(self):
print("姓名: ",self.name,"年龄: ",self.age,"性别: ",self.gender)
zhangsan = Person("张三",18)
lisi = Person("李四",19,"女")
zhangsan.printInfo()
lisi.printInfo()
del zhangsan
del lisi
输出结果为
姓名: 张三 年龄: 18 性别: 男
姓名: 李四 年龄: 19 性别: 女
Bye bye--from 张三
Bye bye--from 李四
class 类名:
@classmethod
def 类方法名(cls,...):#第一个参数必须是当前类对象class,代表定义这个类方法的类,通过它传递类的属性和方法
方法体
class 类名:
@staticmethod
def 类方法名():# 没有self和cls参数,其他的随意
方法体
__xxx : 私有变量
_xxx : 保护变量
__xxx__ : 专有变量,方法
,比如__init__,__del__,__name__,__doc__,...
class 子类名(父类名)
类属性 = 初值
方法(参数列表)
例子:
class Preson():
money = 10000
def say_hello(self):
print("Hello!")
class Teacher(Preson):
pass#是一条空语句,表示什么都不做
amy = Teacher()
print(amy.money)
amy.say_hello()
输出结果为:
10000
Hello!
公有变量、保护变量、私有变量
继承:是子类自动的共享父类中的属性和方法的机制。
文件对象 = open(文件名, 访问模式)
D:\jupyter\example
\python\file.txt
就是表示D:\jupyter\example\python\file.txt
..
表示,即..\file.txt
在绝对路径中就是D:\jupyter\file.txt
import os
print(os.getcwd())
访问模式 | 执行操作 |
---|---|
‘r’ | 以只读方式打开文件 |
‘w’ | 以写入方式打开文件,回覆盖已经存在的文件 |
‘a’ | 以写入方式打开文件,在末尾追加写入 |
‘+’ | 以可读写的方式打开文件(不能单独使用,加在其他方式的后面) |
‘b’ | 以二进制模式打开文件 |
‘t’ | 以文本模式打开文件(默认) |
可以混合使用,比如:
打开模式 | 执行操作 |
---|---|
‘rb’ | 二进制读写模式 |
‘wb’ | 二级制写模式 |
‘ab’ | 二进制追加模式 |
下面看一个例子:
#首先要在目录下创建一个文件
f = open("D:\lianxi\shendu\myfile.txt")#没有提示说明已经被打开了
#f = open("D:/lianxi/shendu/myfile.txt")
f = open("mypython.txt",'w')#如果在工作路径下找不到这个文件,就会自动创建它
#如果打开以后想要删除这个文件,就会出现错误提示,以为该文件已经在python中打开
文件对象.close()
例如上述:
f.close()#释放文件,要及时关闭,写入操作之后要立刻关闭文件,否则可能没有保存
文件对象.read()
例如,针对前面创建的文件
>>>f = open("mypython.txt")
>>>f.read()
'Python3.0'
但是如果是针对一段一段的文字
>>> f = open("The Zen of Python.txt")
>>> f.read()
'wo shi ni ba ba\nwo shi ni ye ye \nwo bu shi ni ba ba\ndui de'
这里对于换行符也被读出来了
该方法每次只读取文件中的一行
>>> f = open("The Zen of Python.txt")
'wo shi ni ba ba\nwo shi ni ye ye \nwo bu shi ni ba ba\ndui de'
>>> f.readline()
'wo shi ni ba ba\n'
>>> f.readline()
'wo shi ni ye ye \n'
>>> f.readline()
'wo bu shi ni ba ba\n'
>>> f.readline()
'dui de'
>>> f.readline()
''
文件对象.read(字节数)
文件对象.readline(字节数)
例如
>>> f = open("The Zen of Python.txt")
>>> f.readline()
'wo shi ni ba ba\n'
>>> f.readline(6)
'wo shi'
>>> f.read(15)
' ni ye ye \nwo b'
>>> f.readline(100)
'u shi ni ba ba\n'
>>>import this
write(写入内容)
f = open("myfile.txt",'w')
f.write("Hello, World!")
f.close()
>>> f = open("myfile.txt",'w')
>>> f.write("Hello!")
6
>>> f.close()
>>> f = open("myfile.txt")
>>> f.read()
'Hello!'
>>> f.close()
>>> f = open("myfile.txt",'a')
>>> f.write("World!")
6
>>> f.close()
>>> f = open("myfile.txt")
>>> f.read()
'Hello!World!'
>>> f.close()
>>> f = open("myfile.txt",'w')
>>> f.write("Python3.0")
9
>>> f.close()
>>> f = open("myfile.txt")
>>> f.read()
'Python3.0'
>>> f.close()
try:
语句块
except 异常1 as 错误原因:
出现异常1后的处理代码
except 异常2 as 错误原因:
出现异常2后的处理代码
例子:
try:
aList = [0,1,2]
print(aList[3])
print("try语句块继续执行中......")
except IndexError as e:
print(e)
print("异常已处理")
print("程序继续执行中......")
运行结果:
list index out of range
异常已处理
程序继续执行中......
但是通常不会向右边那样做,因为那样会捕获到程序员意想不到的错误
try:
语句块
except 异常 as 错误原因:
出现异常后的处理代码
finally:
语句块
例如:
try:
print("try语句块开始")
f = open('test.txt')
print(f.read())
print("try语句块结束")
except IOError as e:
print("except子句")
print(e)
finally:
print("finally子句")
f.close()
假定该目录下,存在text.txt,且内容仅一个1,不存在文件text1.txt
则,打开test.txt时,输出为
try语句块开始
1
try语句块结束
finally子句
则,打开tes1.txt时,输出为
try语句块开始
except子句
[Errno 2] No such file or directory: 'test1.txt'
finally子句
Traceback (most recent call last):
File "first.py", line 11, in <module>
f.close()
NameError: name 'f' is not defined
f = open("mypython.txt")
print(f.read())
f.close()
运行结果:
Pyhton3.0
为了避免找不到语句而中断执行,使用异常处理语句改善
try:
f = open("mypython.txt")
print(f.read())
except IOError as e:
print(e)
finelly:
f.close()
运行结果,假如没有mypython.txt文件,程序出现错误也不会停止:
[Errno 2] No such file or directory: 'mypython.txt'
为了简化代码,对资源操纵后的清除工作
with open("mypython.txt") as f:#首先打开文件,将对象返回给f
print(f.read())#并打印出内容
# with语句执行完,会自动关闭文件
__enter__()
方法和__exit__()
方法class A():
def __init__(self,val_a):
self.a = val_a
def __enter__(self):
print("class A's __enter__function.")
def __exit__(self,exc_type,exc_val,exc_tb):
print("class A's __exit__function.")
上述可以使用with语句来访问它
with 上下文管理器表达式 [as 变量]:
语句块
with open("mypython.txt") as f:
print(f.read())
__enter__()
方法,as是可选的,如果选择了,就把enter语句的返回值赋给它,否则就会丢弃返回值。__exit__()
方法,因此可以将释放清楚的操作写在这里__exit__()
方法有三个参数;如果with语句块正常结束,那么这三个参数都是none;如果发生异常,那么这三个参数的值分别是异常的类、实例、跟踪记录__enter__()
方法__exit__()
方法例子:
class File():#是一个上下文管理器
def __init__(self,filename,mode):#首先,声明文件类,filename文件名,mode访问方式
print("执行__init__()方法")
self.filename = filename
self.mode = mode
def __enter__(self):
print("执行__enter__()方法")
self.f = open(self.filename,self.mode)# 打开文件
return self.f#返回文件对象
def __exit__(self, *args):
print("执行__exit__方法")
self.f.close()#关闭文件
with File('mypython.txt','r') as f:
print(f.read())
执行结果:
执行__init__()方法
执行__enter__()方法
Python3.0
执行__exit__方法
采用这种方法,即使执行过程中出现异常,exit语句也会被执行,文件也会被关闭。