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) |
| 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’) |
| flush() | 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。 x = open(‘123.txt’, ‘w’) x.flush() |
| fileno() | 返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如os模块的read方法等一些底层操作上。 x = open(‘123.txt’, ‘w’) y = x.fileno() ;print(y) |
| isatty() | 如果文件连接到一个终端设备返回 True，否则返回 False。 x = open(‘123.txt’, ‘w’) y = x.isatty() ;print(y) |
| read(x) | 从文件读取指定的字节数，如果未给定或为负则读取所有。 x = open(‘123.txt’, ‘r’) y = x.read(10);print(y) |
| readline() | 读取整行，包括 “\n” 字符。 x = open(‘123.txt’, ‘r’) y = x.readline();print(y) |
| readlines() | 方法用于读取所有行(直到结束符 EOF)并返回列表， 该列表可以由 for… in … 结构进行处理。 如果碰到结束符 EOF 则返回空字符串。 x = open(‘123.txt’, ‘r’) for line in x.readlines() line = line.strip() # 去掉空白符 print(line) # 读取每一行 |
| 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) |
| truncate(x) | 从文件的首行首字符开始截断，截断文件为 x 个字符， 无 x 表示从当前位置截断；截断之后后面的所有字符被删除， 其中 windows 系统下的换行代表2个字符大小。 x = open(‘123.txt’, ‘w’) x.truncate(10) print(x.read()) |
| write(x) | 将字符串写入文件，返回的是写入的字符长度。 x = open(‘123.txt’, ‘w’) x.write(‘123456’) print(x.read()) |
| writelines(y) | 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。 x = open(‘123.txt’, ‘w’) y = [‘1\n’,’2\n’,’3\n’] x.writelines(y) |
三、面向对象
类的定义: 用来描述具有相同的属性和方法的对象的集合。
类的方法：类中定义的函数。
类的变量：类变量在整个实例化的对象中是公用的。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写。
局部变量：定义在方法中的变量，只作用于当前实例的类。
实例变量：在类的声明中，属性是用变量来表示的，这种变量就称为实例变量。
类的继承：继承基类的字段和方法。
类实例化：创建一个类的实例，类的具体对象。
类的对象：通过类定义的数据结构实例。
1.类的创建
class MyClass:
x = 1232.类的实例
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 world3.类的调用
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)
# 输出： 小漫注意：
类调取其他类属性名时，如遇两个类内包含相同属性名，优先取第一个参数类内属性值，如类内存已在该属性名，优先调取类内自身属性值。
文章出处登录后可见！
