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)的变量, 只能是允许这个类本身进行访问了。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
