Python系列教程--python初级第三章

Python初级

函数

自定义函数

函数定义采用def关键字进行定义，只需要声明输入参数，返回结果根据函数体内的return语句来定义

# 函数定义
# 无参 无返回结果
def say():
    print(' say.........')


# 午参 有返回结果
def say1():
    print('say1.......')
    return 'abc'

# 有参数的方法
def say2(id):
    # 不会自动进行类型转换，需要使用函数进行类型转换
    print('打印' + str(id))


# 带默认值的参数的方法
def say3(id,age=100):
    print('print:id'+str(id),age)


# say3有默认参数，调用时可以只调用1哥参数
say3(900)
# 也可以覆盖默认参数
say3(800,200)

# 可变参数,可变参数底层是一个原则tuple
def say4(id,*age):
    print('id:'+str(id))
    print(type(age))
    print(len(age))


# 调用带可变参数的方法
say4(10000,2,'a')
say()
value = say1()
print(value)
say2(100)

**注意：**在函数体中定义的变量我们成为局部变量，局部变量在函数体结束后消失，这是她的作用域，后期返回结果值，输入参数也可以是对象

lambda函数

python 使用 lambda 来创建匿名函数。

• lambda只是一个表达式，函数体比def简单很多。
• lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
• lambda函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
• 虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。

# 匿名函数
sum = lambda a,b: a+b
print(sum(1,2))

模块

Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。

模块让你能够有逻辑地组织你的 Python 代码段。

把相关的代码分配到一个模块里能让你的代码更好用，更易懂。

模块能定义函数，类和变量，模块里也能包含可执行的代码。

自定义一个mymath的py文件，包含有自定义的数学操作

# 自定义的数学模块

def sum(a, b):
    return a+b


def cj(a, b):
    return a*b

在test.py中如何使用mymath中的函数

# 单个导入
# from mymath import sum
# 导入所有
from mymath import *
print(sum(100,200))
print(cj(100,200))

# 单个导入
# from mymath import sum
# 导入所有
# from mymath import *
import mymath
print(mymath.sum(100,200))
print(mymath.cj(100,200))

当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。

搜索路径是一个解释器会先进行搜索的所有目录的列表。

当你导入一个模块，Python 解析器对模块位置的搜索顺序是：

• 1、当前目录
• 2、如果不在当前目录，Python 则搜索在 shell 变量 PYTHONPATH 下的每个目录。
• 3、如果都找不到，Python会察看默认路径。UNIX下，默认路径一般为/usr/local/lib/python/。

模块搜索路径存储在 system 模块的 sys.path 变量中。变量里包含当前目录，PYTHONPATH和由安装过程决定的默认目录。

文件I/O

输出到屏幕print

最简单的输出方法是用print语句，你可以给它传递零个或多个用逗号隔开的表达式。此函数把你传递的表达式转换成一个字符串表达式打印在控制台

print('helloWorld')
print('helloWorld',name)

输入

Python提供了两个内置函数从标准输入读入一行文本，默认的标准输入是键盘。如下：

• raw_input
• input

raw_input函数(python3弃用)

raw_input([prompt]) 函数从标准输入读取一个行，并返回一个字符串（去掉结尾的换行符）

input函数

input([prompt]) 函数和 raw_input([prompt]) 函数基本类似，但是 input 可以接收一个Python表达式作为输入，并将运算结果返回。

while True:
    str2 = input('输入用户信息')
    print(str2)

输入用户信息admin
admin
输入用户信息[1,2,3,'sofwin']
[1,2,3,'sofwin']
输入用户信息

打开文件

Python open() 方法用于打开一个文件，并返回文件对象，在对文件进行处理过程都需要使用到这个函数，如果该文件无法被打开，会抛出 OSError。

**注意：**使用 open() 方法一定要保证关闭文件对象，即调用 close() 方法。

open() 函数常用形式是接收两个参数：文件名(file)和模式(mode)。

open(file, mode='r')

完整的语法格式为：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

参数说明:

• file: 必需，文件路径（相对或者绝对路径）。
• mode: 可选，文件打开模式
• buffering: 设置缓冲
• encoding: 一般使用utf8
• errors: 报错级别
• newline: 区分换行符
• closefd: 传入的file参数类型
• opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

mode 参数有：

模式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（不推荐）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

默认为文本模式，如果要以二进制模式打开，加上 b 。

# 文件操作
file1 = open('a.txt', mode='r+')
# 返回文件的名称
print(file1.name)

# 模式
print(file1.mode)
# 文件写内容
file1.write('这是我写入的内容')
# 读取文件中的内容
nr = file1.read(100)
line = file1.tell()
print(line)
print(nr)
print(file1)
# 是否已关闭
print(file1.close())
# 创建文件 并写入您好，中国
file2 = open('china.txt',mode='w+')
file2.write('您好中国')
file2.write("Hello China")
print(file2.read(100))
file2.close()

异常

异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。

一般情况下，在Python无法正常处理程序时就会发生一个异常。

异常是Python对象，表示一个错误。

当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。

捕捉异常可以使用try/except语句。

try/except语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理。

如果你不想在异常发生时结束你的程序，只需在try里捕获它。

语法：

以下为简单的try…except…else的语法：

try:
<语句>        #运行别的代码
except <名字>：
<语句>        #如果在try部份引发了'name'异常
except <名字>，<数据>:
<语句>        #如果引发了'name'异常，获得附加的数据
else:
<语句>        #如果没有异常发生

try的工作原理是，当开始一个try语句后，python就在当前程序的上下文中作标记，这样当异常出现时就可以回到这里，try子句先执行，接下来会发生什么依赖于执行时是否出现异常。

• 如果当try后的语句执行时发生异常，python就跳回到try并执行第一个匹配该异常的except子句，异常处理完毕，控制流就通过整个try语句（除非在处理异常时又引发新的异常）。
• 如果在try后的语句里发生了异常，却没有匹配的except子句，异常将被递交到上层的try，或者到程序的最上层（这样将结束程序，并打印默认的出错信息）。
• 如果在try子句执行时没有发生异常，python将执行else语句后的语句（如果有else的话），然后控制流通过整个try语句。

# 异常 try except else
try:
    num1 = 1
    print(num1 / 0)
except:
    print('异常')
else:
    print('正常')

# try finally
try:
    num1 = 1
    print(num1 / 0)
except:
    print('对不起，异常了')
finally:
    print('关闭连接')

面向对象

面向对象技术简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。 等同于java累
• **类变量：**类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。等同于静态成员变量
• **数据成员：**类变量或者实例变量, 用于处理类及其实例对象的相关的数据。成员变量+静态成员变量
• **方法重写：**如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。java重写
• **局部变量：**定义在方法中的变量，只作用于当前实例的类。 局部变量
• **实例变量：**在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。 成员变量
• **继承：**即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。多继承，通过括号来定义父累
• **实例化：**创建一个类的实例，类的具体对象。实力化不需要new
• **方法：**类中定义的函数。方法
• **对象：**通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

简单类的创建

​ 语法

class 类名:
	实力变量
	def 方法

# 类
# 重建人

class Human:
    sex = '男'
    age = 100
    name = '张三'

    # 函数 self代表实例，代表当前对象的地址
    def say(self):
        print(id(self))
        print(self.name + ":" + str(self.age))


# 实力化

user = Human()
user.say()
print(user.sex)
# 我们发现user打印除的地址和self打印的地址是一样的
print(id(user))

内置属性

• dict : 类的属性（包含一个字典，由类的数据属性组成）
• doc :类的文档字符串
• name: 类名
• module: 类定义所在的模块（类的全名是’main.className’，如果类位于一个导入模块mymod中，那么className.module 等于 mymod）
• bases : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

# 类
# 重建人
# 这是用户
class Human:
    # 类的文档 == java的文档注释
    '所有人的父类'
    sex = '男'
    age = 100
    name = '张三'

    # 函数 self代表实例，代表当前对象的地址
    def say(self):
        print(id(self))
        print(self.name + ":" + str(self.age))


# 实力化

user = Human()
user.say()
print(user.sex)
# 我们发现user打印除的地址和self打印的地址是一样的
print(id(user))
# 字典 字典中包含类的方法，成员变量等
print(Human.__dict__)
print(Human.__doc__)
# 类名
print(Human.__name__)
# 模块
print(Human.__module__)
# 所有父级元素  所有类的父类是Object
print(Human.__bases__)	

类的继承

# man继承human
class Man(Human):
    '男人'
    hz = '有胡子'

    def smoking(self):
        print('抽烟：' + self.hz)


man = Man()
man.smoking()
man.say()

基础重栽方法

下表列出了一些通用的功能，你可以在自己的类重写：

序号	方法, 描述 & 简单的调用
1	init ( self [,args…] ) 构造函数 简单的调用方法: obj = className(args)
2	del( self ) 析构方法, 删除一个对象 简单的调用方法 : del obj
3	repr( self ) 转化为供解释器读取的形式 简单的调用方法 : repr(obj)
4	str( self ) 用于将值转化为适于人阅读的形式 简单的调用方法 : str(obj)
5	cmp ( self, x ) 对象比较 简单的调用方法 : cmp(obj, x)

# 类
# 重建人
# 这是用户
class Human:
    # 类的文档 == java的文档注释
    '所有人的父类'
    sex = '男'
    age = 100
    name = '张三'

    # __init__ 构造方法 因为重载了构造方法，所以子类必须重载构造方法
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex

    # 函数 self代表实例，代表当前对象的地址
    def say(self):
        print(id(self))
        print(self.name + ":" + str(self.age))


# man继承human
class Man(Human):
    '男人'
    hz = '有胡子'

    def __init__(self):
        super().__init__('name1', 'sex1')

    def smoking(self):
        print('抽烟：' + self.hz)


man = Man()
man.smoking()
man.say()

以上代码中对象的属性和方法可以在任意位置访问

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法

在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，不能在类的外部调用。在类的内部调用 self.__private_methods

# 类
# 重建人
# 这是用户
class Human:
    # 类的文档 == java的文档注释
    '所有人的父类'
    sex = '男'
    age = 100
    # 定义该成员变量为私有成员变量
    __name = '张三'

    # __init__ 构造方法 因为重载了构造方法，所以子类必须重载构造方法
    def __init__(self, name, sex):
        print('这是构造方法中的私有变量', name)
        self.__name = name
        self.sex = sex

    # 函数 self代表实例，代表当前对象的地址
    def say(self):
        print(id(self))
        print(self.__name + ":" + str(self.age))


# man继承human
class Man(Human):
    '男人'
    hz = '有胡子'

    def __init__(self):
        super().__init__('name1', 'sex1')

    def smoking(self):
        self.__privateMethod()
        print('抽烟：' + self.hz)

    def __privateMethod(self):
        print('私有方法')


man = Man()
man.smoking()
man.say()
# 私有成员变量不能访问
# print(man.__name)
# print(man.__privateMethod)
print(man.hz)

单下划线、双下划线、头尾双下划线说明：

• foo: 定义的是特殊方法，一般是系统定义名字 ，类似 init() 之类的。
• _foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *
• __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。