Python基础知识入门（五）

Python基础知识入门（一）

Python基础知识入门（二）

Python基础知识入门（三）

Python基础知识入门（四）

一、模块应用

模块是一个包含所有定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数、变量等功能来完成数据处理。

1.模块导入

import a 导入名称为 a 的模块，调用时使用 a.x （x为函数、变量名）进行调用，例如：导入import random，调用random.randint()。

from a import b 导入名称为 a 的模块中名称为 b 的函数或变量，调用时使用 b 直接调用，例如：导入from random import randint ，调用randint()。

from a import* 导入名称为 a 的模块所有方法，调用时直接使用函数或变量名进行调用，例如：导入from random import*，调用randint()。

2.模块别名

import aaa as a 在使用过程中如名称太长，可用 as 修改模块名字，修改后用a.x进行调用，例如： import random as rd，调用rd.randint()。

3.name

每个模块都有一个__name__属性，其值是'__main__'时，表明该模块自身在运行，否则是被引入。如不想让模块中的某些代码执行，可以用__name__属性来使程序仅调用模块中的一部分。

# YKH.py

print('我是 YKH 模块__name__值：'+__name__)
if __name__ == '__main__':
  print('YKH 模块被直接运行了')

# 我是 YKH 模块__name__值：__main__
# YKH 模块被直接运行

注意：

__name__ == '__main__'在自身模块调用时，值为'__main__'，

且执行 if __name__ == '__main__' 下所有内容。

# x.py

print('我是 x 模块__name__值：'+__name__)
if __name__ == '__main__':
  print('x 模块被直接运行了')

# y.py

import x
print('我是 y 模块__name__值：'+__name__)
if __name__ == '__main__':
  print('y 模块被直接运行了')

# 我是 x 模块__name__值 x
# 我是 y 模块__name__值__main__
# y 模块被直接运行

注意：

__name__ == '__main__'在自身模块调用时，值为'__main__'，且执行if __name__ ==

'__main__' 下所有内容，调用其他模块时 __name__ 值为调入模块名，所以 __name__ 值不

为'__main__'，故不会执行调入模块下if __name__ == '__main__' 下所有内容。

4.dir()函数

内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回。

import random
print(dir(random))

['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 
'SG_MAGICCONST', 'SystemRandom', 'TWOPI', '_Sequence', 
'_Set', '__all__', '__builtins__', '__cached__', '__doc__', 
'__file__', '__loader__', '__name__', '__package__', '__spec__',
 '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '_exp', 
'_inst', '_log', '_os', '_pi', '_random', '_repeat', '_sha512', 
'_sin', '_sqrt', '_test', '_test_generator', '_urandom', '_warn', 
'betavariate', 'choice', 'choices', 'expovariate', 'gammavariate', 
'gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', 
'paretovariate', 'randint', 'random', 'randrange', 'sample', 'seed', 
'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate', 
'weibullvariate']

5.常用模块

1）random

函数	描述（import random）
random()	在[0,1)范围内随机生成一个浮点数。如random.random()
uniform(x,y)	[x,y]范围内随机生成一个浮点数。如random.uniform(3,5)。
randint(x,y)	在指定范围内随机一个整数。如random.randint(1,10)。
randrange([start,] stop [,step])	指定范围内按指定基数递增集合中获取一个随机数，默认值为 1。 start -- 指定范围内的开始值，包含在范围内。 stop -- 指定范围内的结束值，不包含在范围内。 step -- 指定递增基数。如random.randrange(1, 100, 2)从 1-100 中选取一个奇数。
choice(x)	从序列x中随机挑选一个元素，x --可以是一个列表、元组、字符串。如random.choice(range(10))，从0到9中随机挑选一个整数。
sample(x,y)	从序列中随机指定个数的元素。如x = [1,2,3,4,5]，random.sample(x,3)。
seed([x])	改变随机数生成器种子，需在调用其他随机函数之前调用此函数。如random.seed(8)，提前指定种子数字为8。
shuffle(x)	将序列x的所有元素随机排序。如random.shuffle(x)。

2）time、datetime

函数	描述（import time）
time()	返回当前时间的时间戳（1970纪元后经过的浮点秒数）。 time.time()，返回 1668499929.629205 。
sleep(x)	推迟调用线程的运行，可通过参数x指秒数，表示进程挂起的时间。 time.sleep(3)，延迟3秒后继续执行。
asctime(x)	返回一个可读的形式为"Tue（星期） Nov（月份） 15 06:56:32 2022" （2022年11月15日周二06时56分32秒）的24个字符的字符串。time.asctime()，返回 Tue Nov 15 06:56:32 2022。 time.asctime(time.gmtime())，返回 Tue Nov 15 06:56:32 2022。 time.asctime(time.localtime())，返回 Tue Nov 15 06:56:32 2022。
ctime(x)	把时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如参数为None的时候，将会默认time.time()为参数。 time.ctime()，返回 Tue Nov 15 06:56:32 2022。
gmtime(x)	将一个时间戳转换为UTC时区（0时区）的struct_time，如参数为None，默认time.time()为参数。 time.gmtime()，返回 time.struct_time(tm_year=2022, tm_mon=11, tm_mday=15, tm_hour=7, tm_min=14, tm_sec=54, tm_wday=1, tm_yday=319, tm_isdst=0) 。
localtime(x)	类似gmtime()，作用是格式化时间戳为本地的时间。如参数为None，默认time.time()为参数。 time.localtime()，返回 time.struct_time(tm_year=2022, tm_mon=11, tm_mday=15, tm_hour=7, tm_min=14, tm_sec=54, tm_wday=1, tm_yday=319, tm_isdst=0)
mktime(x)	与gmtime(), localtime()相反的操作，它接收struct_time对象作为参数，返回用秒数来表示时间的浮点数。 x = (2022,11,15,6,56,32,1,319,0) time.mktime(x)，返回 1668495392.0 。
strftime(x)	格式化时间，返回可读字符串表示的当地时间，格式由参数 x 决定。 time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()) 返回 2022-11-15 07:57:58 。
strptime(x)	根据指定的格式把一个时间字符串解析为时间元组。 time.strptime("15 Nov 22 32 56 06", "%d %b %y %S %M %H") 返回 time.struct_time(tm_year=2022, tm_mon=11, tm_mday=15, tm_hour=6, tm_min=56, tm_sec=32, tm_wday=1, tm_yday=319, tm_isdst=-1) 。

函数	描述（import datetime）
now()	获取当前日期和时间。 datetime.datetime.now()，返回 2022-11-16 06:06:16.112800 。
today()	获取当前日期和时间。 datetime.date.today()，返回 2022-11-16 。 datetime.datetime.today()，返回 2022-11-16 08:27:33.373906 。
year	获取日期年。 datetime.date.today().year ，返回 2022 。 datetime.datetime.today().year ，返回 2022 。
month	获取日期月。 datetime.date.today().month，返回11 。 datetime.datetime.today().month，返回 11 。
day	获取日期日。 datetime.date.today().day，返回 16 。 datetime.datetime.today().day，返回16 。
hour	获取时间小时。 datetime.datetime.today().hour，返回 12 。
minute	获取时间分钟。 datetime.datetime.today().minute，返回 13 。
second	获取时间秒数。 datetime.datetime.today().second，返回 15 。
isocalendar()	返回一个包含三个值的元组，三个值依次为：年份，周数，星期数（周一为1…周日为7) 。 datetime.date.today().isocalendar() ，返回 (2022, 46, 3)。
weekday()	返回指定日期所在的星期数（周一为 0, 周日为 6 ） datetime.datetime.today().weekday()，返回 2 。
isoweekday()	返回符合ISO标准的指定日期所在的星期数（周一为1…周日为7) 。 datetime.datetime.today(). isoweekday()，返回 3 。
toordinal()	返回公元公历开始到现在的天数。公元1年1月1日为1 。 datetime.date.today().toordinal()，返回 738475。
fromtimestamp()	根据给定的时间戮，返回一个date对象。 datetime.date.fromtimestamp(1668588740.0) ，返回 2022-11-16。
timetuple()	将时间日期格式化，返回一个类型为time.struct_time的数组。 datetime.datetime.today().timetuple() ，返回 time.struct_time(tm_year=2022, tm_mon=11, tm_mday=16, tm_hour=8, tm_min=39, tm_sec=28, tm_wday=2, tm_yday=320, tm_isdst=-1) 。
strftime(x)	格式化时间，返回可读字符串表示的当地时间，格式由参数 x 决定。 datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")，返回 2022-11-16 06:36:32 。
timedelta()	在指定日期时间基础上增加指定时间和时间。 datetime.datetime.now() + datetime.timedelta(days = 5) 加5天。 datetime.datetime.now() + datetime.timedelta(days = -5) 减5天。 datetime.datetime.now() + datetime.timedelta(hours=5) 加5小时。 datetime.datetime.now() + datetime.timedelta(minutes=5) 加5分钟。 datetime.datetime.now() + datetime.timedelta(seconds=300) 加5秒钟。

struct_time元组属性如下：

属性	描述
tm_year	2022 年
tm_mon	1 到 12 月
tm_mday	1 到 31 日
tm_hour	0 到 23 时
tm_min	0 到 59 分
tm_sec	0 到 61 (60或61 是闰秒) 秒
tm_wday	0到6 (0是周一) 一周的第几日
tm_yday	1 到 366(儒略历) 一年的第几日
tm_isdst	-1, 0, 1 1 - 夏令时 0 - 非夏令时 -1 - 未确定夏令时

时间日期格式化符号属性如下：

符号	描述
%a	本地简化星期名称。
%A	本地完整星期名称。
%b	本地简化的月份名称。
%B	本地完整的月份名称。
%c	本地相应的日期表示和时间表示。
%C	年份的前两位。
%d	月内中的一天（0-31）。
%D	当前日期（11/15/22）
%e	每月的第几天。
%F	当前日期（2022-11-15）
%g	年份的后两位。
%G	当前日期年份。
%h	英文简写月份名。
%H	24小时制小时数（0-23）。
%I	12小时制小时数（01-12）。
%j	年内的一天（001-366）。
%m	月份（01-12）。
%M	分钟数（00-59）。
%p	本地A.M.或P.M.的等价符。
%r	12小时时间（12:26:15 AM）
%R	显示当前时:分（08:27）。
%S	秒（00-59）。
%u	星期（0-6），每周第几天。
%U	一年中的星期数（00-53）。
%V	每年的第几周，使用基于周的年。
%w	星期（0-6），每周第几天。
%W	一年中的星期数（00-53）。
%x	本地相应的日期表示。
%X	本地相应的时间表示。
%y	两位数的年份表示（00-99）。
%Y	四位数的年份表示（000-9999）。
%z	与utc时间的间隔（如果不存在为空字符）
%Z	时区的名字（如果不存在为空字符）
%%	%号本身。

3）math

函数	描述（import math）
sqrt(x)	计算平方根，返回的数据为浮点型数据。 math.sqrt(9)，3.0 。
log(x,y)	计算对数，其中x为真数，y为底数。 math.log(100,10)，2.0 即 100是10^2 。
ceil(x)	向上取整操作。 math.ceil(1.23)，2 。
floor(x)	向下取整操作。 math.floor(1.50)，1 。
pow(x,y)	计算 x 的 y 次方。 math.pow(2,3)，8.0 。
fabs(x)	计算一个数值的绝对值。 math.fabs(-123)，123.0 。
pi	圆周率 π 。 math.pi，3.141592653589793 。
e	自然常数 e 。 math.e，2.718281828459045 。
trunc(x)	返回x的整数部分。 math.trunc(12.36)，12 。
modf(x)	返回x的小数和整数。 math.modf(12.36)，(0.35999......, 12.0) 。
fmod(x,y)	取余。 math.fmod(3,2)，1.0 。
fsum(x)	返回序列中各元素之和。 math.fsum([1,2,3,4,5])，15.0 。
factorial(x)	返回x的阶乘。 math.factorial(3)，6 。
gcd(x,y)	返回整数x和y的最大公约数。 math.gcd(2,6)，2 。

二、文件操作

open() 方法用于打开一个文件，并返回文件对象。如果该文件无法被打开，会抛出 OSError。

注意：

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

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

1.mode 参数

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

2.file对象

方法	描述
close()	关闭文件。关闭后文件不能再进行读写操作。 x = open('123.txt', 'w') x.close()
flush()	刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。 x = open('123.txt', 'w') x.flush() x.close()
fileno()	返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。 x = open('123.txt', 'w') y = x.fileno() ;print(y) x.close()
isatty()	如果文件连接到一个终端设备返回 True，否则返回 False。 x = open('123.txt', 'w') y = x.isatty() ;print(y) x.close()
read(x)	从文件读取指定的字节数，如果未给定或为负则读取所有。 x = open('123.txt', 'r') y = x.read(10);print(y) x.close()
readline()	读取整行，包括 "\n" 字符。 x = open('123.txt', 'r') y = x.readline();print(y) x.close()
readlines()	方法用于读取所有行(直到结束符 EOF)并返回列表，该列表可以由 for... in ... 结构进行处理。如果碰到结束符 EOF 则返回空字符串。 x = open('123.txt', 'r') for line in x.readlines() line = line.strip() # 去掉空白符 print(line) # 读取每一行 x.close()
seek(x)	移动文件读取指针到指定位置 x = open('123.txt', 'w') x.write('123456') y = x.seek(3);y=3 x.close()
tell()	返回文件当前位置。 x = open('123.txt', 'w') y = x.tell();print(y) x.close()
truncate(x)	从文件的首行首字符开始截断，截断文件为 x 个字符，无 x 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。 x = open('123.txt', 'w') x.truncate(10) print(x.read()) x.close()
write(x)	将字符串写入文件，返回的是写入的字符长度。 x = open('123.txt', 'w') x.write('123456') print(x.read()) x.close()
writelines(y)	向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。 x = open('123.txt', 'w') y = ['1\n','2\n','3\n'] x.writelines(y) x.close()

三、面向对象

类的定义: 用来描述具有相同的属性和方法的对象的集合。

类的方法：类中定义的函数。

类的变量：类变量在整个实例化的对象中是公用的。

数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。

方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写。

局部变量：定义在方法中的变量，只作用于当前实例的类。

实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量。

类的继承：继承基类的字段和方法。

类实例化：创建一个类的实例，类的具体对象。

类的对象：通过类定义的数据结构实例。

1.类的创建

class MyClass:
  x = 123

2.类的实例

class MyClass: 
  x = 123                 # 类属性

myclass = MyClass()       # 实例化
print(myclass.x)          # 调用类属性

# 输出：123

-------------------------------------------------
class MyClass:
  x = 123                
  def y(self):
    return 'hello world'  # 类方法内容

myclass = MyClass()       # 实例化
print(myclass.y())        # 调用类方法 

# 输出：hello world

3.类的调用

class MyClass:
  x = 1.80
  def y(self):
    return '我的身高是{}米。'.format(self.x) # 调用类内部属性

myclass = MyClass()
print(myclass.y())  

# 输出：我的身高是1.8米。

注意：

1.创建类的方法时，必需要将第一个参数留给 self，并在调用的时候忽略它。

2.在类的方法中调用类的属性和方法时，要通过self.属性名或 self.方法名（）格式调用。

4. init

__init__() 被称为类的构造函数或初始化方法，

当类实例化操作后会自动调用 __init__() 方法。

class MyClass:
  def __init__(self,x,y):
  	self.x = x             
	self.y = y

myclass = MyClass(6,3)
print(myclass.x)

# 输出：6

------------------------------------------
class MyClass:
  def __init__(self,x):
  	self.x = x
	print('实例化被打印')

myclass = MyClass(6)        

# 输出：实例化被打印

注意：

类初始化__init__实例化后会直接被执行打印print()里内容。

5.str

当使用print输出对象的时候，若定义了__str__(self)方法，

打印对象时就会从这个方法中打印出return的字符串数据。

class MyClass:
  def __init__(self,x):
  	self.x = x
  def __str__(self):
	return '我的身高是：{} 米 。'.format(self.x)

myclass = MyClass(1.80)
print(myclass)

# 输出：我的身高是1.8米。

若将__str__方法注释之后，print输出对象变量，默认情况下，

输出变量引用对象是哪一个类创建的对象，以及在内存地址。

class MyClass:
  def __init__(self,x):
  	self.x = x

myclass = MyClass(1.80)
print(myclass)

# 输出：<__main__.MyClass object at 0x00000000026F90F0>

6.类的继承

class A():
  name = '漫漫'
class B(A):      # 继承类 A 的所有方法和属性
  pass

b = B()
print(b.name)

# 输出:漫漫

-------------------------------------------------------
class A():
  name = '漫漫'
class B():
  name = '桔子'
class C(B,A):  # 优先继承第一个类方法和属性
  pass

c = C()
print(c.name)

# 输出：桔子

-------------------------------------------------------
class A():
  name = '漫漫'
class B():
  name = '桔子'
class C(A,B):    # 优先使用类自身方法和属性
  name = '小漫'

c = C()
print(c.name)

# 输出： 小漫

注意：

类调取其他类属性名时，如遇两个类内包含相同属性名，优先取第一个参数类内属性值，如类内存已在该属性名，优先调取类内自身属性值。