总字符数: 40.23K

代码: 24.94K, 文本: 6.91K

预计阅读时间: 2.31 小时

Python程序的基本构成

Python标识符

标识符的定义

标识符(identifief)是指用来标识某个实体的一个符号,在不同的应用环境下有不同的含义.在计算机编程语言中,标识符是用户编程时使用的名字,用于给变量、常量、函数、语句块等命名,以建立起名称与使用之间的关系.

标识符的命名规则

1
2
3
4
5
6
7
 第一个字符必须是字母表中字母或下划线_.
 标识符的其他的部分由字母、数字和下划线组成.
 标识符对大小写敏感.
 在Python3中,可以用中文作为变量名,非ASCI标识符也是允许的了
 这些保留字不能用作常数或变数,或任何其他标识符名称
 and  exec  not  assert  finally  or  break  for  pass  class  from  print  continue  global  raise  def  if
return  del  import  try  elif  in  while  else  is  with  except  lambda  yield

注释

1
2
3
Python中的注释有单行注释和多行注释
单行注释以#开头
多行注释用三个单引号'''或者三个双引号"""将注释括起来

数据类型

  1. 数字(Number)类型 

    1
    2
    3
    4
    5
    python中数字有四种类型:整型、布尔型、浮点数和复数.
        int(整数),如1,只有一种整数类型int,表示为长整型,没有python2中的Long(长整型)
        bool (布尔),如True
        float(浮点数),如1.23、3E-2
        complex(复数),如1+2j、1.1+2.2j

  2. 字符串(String)

    python中单引号和双引号使用完全相同。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    # 多行字符串注释
    """
    使用三个引号(单引号或双引号)
    可以创建多行字符串
    """


    # 使用转义符
    "转义字符如\\n表示换行"

    # 原始字符串
    r"在字符串前加r可使\\n成为两个普通字符:\\n"

    # 字符串连接和重复
    "连接" + "字符串"  # 输出 '连接字符串'
    "重复" * 3         # 输出 '重复重复重复'

    # 字符串的截取的语法格式如下:变量[头下标:尾下标]

     案例:
            str = 'AnQuanNiu'
            print(str)              #输出字符串
            print(str[0:-1])        #输出第一个到倒数第二个的所有字符
            print(str[0])           #输出第一个字符
            print(str[2:5])         #输出从第三个开始到第五个的字符
            print(str[2:])          #输出从第三个开始后的所有字符
            print(str* 2)           #输出字符串两次
            print(str +'你好')     #连接字符串
            print('-------------------------')
            print('hello\\nAnQuanNiu')   #使用反斜杠(\)+n转义特殊字符
            print(r'hello\AnQuanNiu')    #在字符电前面添加一个r,表示原始字符串,不会发生转义

  3. 空值 

    1
    2
    3
    4
    5
    在Python中,可直接用True和False表示布尔值,也可通过布尔运算计算出来
       print(True)True
       print(False)False
       print(3>2)ture
       print(3>5)False

类型转换

以下几个内置的函数可以执行数据类型之间的转换.这些函数返回一个新的对象,表示转换的值.

函数 描述
int(x [,base]) 将x转换为一个整数
float(x) 将x转换到一个浮点数
complex(real [,imag]) 创建一个复数
str(x) 将对象 x 转换为字符串
repr(x) 将对象 x 转换为表达式字符串
eval(str) 用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s) 将序列 s 转换为一个元组
list(s) 将序列 s 转换为一个列表
set(s) 转换为可变集合
dict(d) 创建一个字典.d 必须是一个 (key, value)元组序列.
frozenset(s) 转换为不可变集合
chr(x) 将一个整数转换为一个字符
ord(x) 将一个字符转换为它的整数值
hex(x) 将一个整数转换为一个十六进制字符串
oct(x) 将一个整数转换为一个八进制字符串

输入与输出

  1. Print输出
    1. print默认输出是换行的,如果要实现不换行需要在变量末尾加上end=””
  2. Input输入
    1. input("\n\n按下enter 键后退出.")

变量

变量在程序中用一个变量名表示,变量名必须是字母、数字和下划线的组合,且不能以数字开头

1
2
3
4
5
6
7
8
9
n = 1#变量n是一个整数
a=1.0 #变量a是一个浮点数
str ='Hello world!' #变量str是一个字符串
question = True #变量question是一个布尔值
可以把一个变量a赋值给另一个变量b,这个操作实际上是把变量b指向a所指向的数据,如
a ='ABC'
b= a
a ='XYZ'
print(b)

常量

在Python中,通常用全部大写的变量名表示常量

1
2
3
如:
    Pl= 3.1415926 
注:用全部大写的变量名表示常量只是一个习惯上的用法

多行语句

Python通常是一行写完一条语句,但如果语句很长,我们可以使用反斜杠()来实现多行语句,例如:

1
2
3
4
5
total = 'item_one' +\
        'item_two' +\
        'item_three'
在[],{},或()中的多行语句,不需要使用反斜杠(\),例如:
total = ['item_one','item_two','item_three','item_four','item_five']

格式化字符串与编码

格式化字符串

    python格式化字符串的使用方式类似于C语言,使用占位符来格式化字符串

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
														输出
print('Hello,%s!'%'world')                         Hello , world!
name ='Ming' 
age = 23
print("Hello , %s.You are %s." %(name, age))      Hello,Ming.You are 23.
常用占位符
    占位符        替换内容
    %d            整数
    %f            浮点数
    %s            字符串
    %x            十六进制整数
python常见的几种格式化字符串有r字符串、b字符串、f字符串.
  f字符串从Python 3.6开始加入标准库,也被称为"格式化字符串文字".与其他格式化方式相比,它们不仅更易读,更简洁,不易出错,而且速度更快
   												 输出
name = 'XiaoMing'
age = 23
print(f'Hello,{name}.You are {age}.')         Hello ,XiaoMing.You are 23.
print(f'Hello,{name}.You are {age}.')         Hello , XiaoMing.You are 23.
注:f字符串是在运行时进行渲染的,因此可以将任何有效的Python表达式放入其中
编码
当Python解释器读取源码时,为了让它按UTF-8编码读取,通常在文件开头处写上这两行:
#!/usr/bin/env python3
#-*- coding: utf-8-*-
第一行是为了告诉Linux/OSx系统,这是一个Python可执行程序,Windows系统会忽略这个注释;
第二行是为了告诉Python解释器,按照UTF-8编码读取源码.否则,源码中写的中文在输出时可能会有乱码.

列表

​ 列表(list):列表由一组元素组成.每个元素可以存储不同类型的数据,如字符串、数字甚至元素.

​ 列表可以实现添加、删除和查找操作,元素的值可以被修改.

​ 列表是传统意义上的数组 列表用”[]”标识

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 列表创建示例如下:
list = ["test1",786,2.23,"test2",70.2]
tinylist = [123,'test3']
print (list)         #输出完整列表
print (list[0])           #输出列表的第一个元素
print (list[1:3])         #输出第二个至第三个元素
print (list[2:])  #输出从第三个开始至列表末尾的所有元素
print (tinylist* 2)   #输出列表两次
print (list+ tinylist)  #打印组合的列表
tinylist.append(6)   #将6添加到tinylist列表中
print(tinylist)
del tinylist[-1]    #删除最后一个元素
print(tinylist)
tinylist[1]=6      #将下标为1的列表内容替换为6
print(tinylist)

元组

​ 元组(tuple)︰元组是另一个数据类型,类似于List(列表).元组往往代表一行数据,而元组中的元素代表不同的数据项.

可以把元组看做不可修改的数组_.元组用”()”标识

1
2
3
4
5
6
7
8
9
10
11
# 创建元组示例如下:
tuple_str=("你好",23,3.32)
print (tuple)                #输出完整元组
 print (tuple[0] )            #输出元组的第一个元素
 print (tuple[1:3])           #输出第二个至第四个(不包含)的元素
 print (tuple[2:])            #输出从第三个开始至列表末尾的所有元素
 print (tinytuple* 2)         #输出元组两次
 print (tuple + tinytuple)    #打印组合的元组
 tuple2 = tuple + tinytuple
 print(tuple2)
 del tuple2                   #删除元组

字典

​ 字典(dictionary) : python之中字典(dictionary)是除列表以外最灵活的内置数据结构类型.

​ 列表是有序的对象集合,字典是无序的对象集合.

两者之间的区别在于:字典当中的元素是通过键来存取 的,而不是通过偏移存取.

字典用”{}”标识.字典由索引(key)和它对应的值value组成.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 创建示例如下
dict= {}
dict['one'] = "This is one"
dict[2]= "This is two"
tinydict = {'name' : 'anguanniu','code':9527,'dept': 'sales'}
print (dict['one'])             #输出键为'one'的值
print (dict[2])                 #输出键为2的值
print (tinydict)                #输出完整的字典
print (tinydict.keys())         #输出所有键
print (tinydict.values())       #输出所有值
tinydict['name'] = 'test'       #将name的值修改为test
print(tinydict['name'])
del tinydict['name']            #删除name的值
print(tinydict)
tinydict.clear()                #清空tintdict字典
print(tinydict)
print(dict.keys())
print(dict.values())

集合

​ 集合(set)是一个无序的不重复元素序列.可以使用大括号{}或者set()函数创建集合,注意:创建一个空集合必须用set()而不是{},因为{}是用来创建一个空字典.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 创建示例如下:
set1 = {'zhangsan','lisi','wanger' ,'wanger'}
print(set1)     # 这里演示的是去重功能
a = 'zhangsan' in set1 #快速判断元素是否在集合内
print(a)
b = 'sdfsdf' in set1
print(b)
#下面展示两个集合间的运算
c = set('abcd')
print(c)
d = set('abcdefg')
print(d)
print(c-d)  #集合c中包含而集合d中不包含的元素
print(d-c)  #集合d中包含而集合c中不包含的元素
print(c|d)  #集合c或d中包含的所有元素
print(c&d)  #集合c和d中都包含了的元素
print(c^d)  #不同时包含于c和d的元素
thisset = set(("BaiDu","TenXun","TaoBao"))
print(thisset)
thisset.add("XiaoMi")   #将XiaoMi添加到thisset集合中
print(thisset)
thisset.remove("XiaoMi")  ##将XiaoMi移除
print(thisset)
thisset.clear()    #清空集合
print(thisset)

条件结构

if else

1
2
3
4
5
#如果满足条件condition_1,则执行代码块statement_block_1否则执行statement_block_2
if condition_1:
    statement_block_1
else:
    statement_block_2

else if

1
2
3
4
5
6
7
8
9
10
11
if condition_1:
    statement_block_1
elif condition_2:
    statement_block_2
else:
    statement_block_3
注意:
1.Python中用elif代替了else if,所以if语句的关键字为: if-elif-else
2.每个条件后面要使用冒号:,表示接下来是满足条件后要执行的语句块.
3.使用缩进来划分语句块,相同缩进数的语句在一起组成一个语句块.
4.在Python中没有switch - case语句.

循环结构

1
2
3
4
for循环(9*9乘法口决表)
for i in range(1,10):
    for j in range(1,i+1):
        print(j,'*',i,'=',(j*i),end='\t')

函数

函数的定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
定义语法def
	def 函数名(参数列表)
        函数体
函数的参数
    函数的参数是指,我们在定义函数的时候,可以传输数据进来,传输的数据就叫参数.
函数的调用
写函数名字,括号中带要处理的参数例子: dec(1,2)函数中的return与输出不一样,只允许return一个返回值(有多个则返回第一个)
输出可以输出很多语句注意,必须按照缩进来写函数例子:
   def dec (a,b)
		return a-b 
 一个函数的参数可以是多个的,或者不带参数的
     例子: def output() : def plus (a,b) :def plus (a,b,c)
函数的参数输入,可以通过外部输入修改赋值顺序
例子: 
    def plus (a,b):
调用:
  plus(b=1,a=2)

内置函数

1
2
3
4
5
6
7
8
9
10
11
type() :读取函数的变量类型
int()∶将参数变量类型修改为整型
float ()∶将参数变量的类型修改为浮点型
str():将参数变量的类型修改为字符串类型
max ()︰取参数的最大值
min()∶取参数的最小值
abs () ︰取参数的绝对值
sum ()︰取参数的总和值
round ():取参数的小数长度
x**y: x的y次方,等同于pow (x,y)函数
len()∶计算参数中有多少字符

标准模块和第三方模块

1
2
3
4
5
# 自带模块
sys time os calendar  urllib json re math  decimal shutil logging tkinter

#第三方模块
pymysql cx_Oracle pygame PIL xlrd xlwt selenium numpy

异常和程序调试

1
2
3
4
5
6
7
8
9
10
11
try:
    程序执行语句块
# 捕获所有错误
except Exception as e:
    异常处理语句块
else:
    无异常时处理语句块
finally:
    必须的处理语句块
    例如:
    mysql.close()
异常 说明
AttributeError 试图访问一个对象没有的属性
IOError 输入/输出异常
ImportError 无法引入模块或包;多是路径问题或名称错误
IndentationError 缩进错误
IndexError 下标索引错误
KeyError 试图访问不存在的键
KeyboardInterrupt Ctrl+C被按下,键盘终止输入
NameError 使用未定义的变量
SyntaxError 语法错误
TypeError 传入对象的类型与要求不符合
UnboundLocalError 试图访问一个还未被设置的局部变量
ValueError 传入一个调用者不期望的值,即使值的类型是正确的

文件和目录操作

文件与持久化

常用的文件分类

  • 配置文件
  • 数据文件
  • 日志文件
  • 数据库文件
  • 声音和图像文件

文件的读写

  • **相对路径:**以引用文件之网页所在位置为参考基础,而建立出的目录路径.因此,当保存于不同目录的网页引用同一个文件时,所使用的路径将不相同,故称之为相对.
  • **绝对路径:**以Web 站点根目录为参考基础的目录路径.之所以称为绝对,意指当所有网页引用同一个文件时,所使用的路径都是一样的.其实绝对路径与相对路径的不同处,只在于描述目录路径时,所采用的参考点不同.由于对网站上所有文件而言,根目录这个参考点对所有文件都是一样的,因此,运用以根目录为参考点的路径描述方式才会被称之为绝对路径
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 文件读取的过程: 1.打开文件 2.读取文件 3.关闭文件
# r:read
# w:write 默认只写的话会清空文档已有的内容
# a+:读写
# r+ 如果文件不存在则会报错
# w+ 如果文件不存在则会创建文件
# rb 以二进制格式打开一个文件用于只读
# "." -- 代表目前所在的目录,相对路径. 如:<a href="./abc">文本</a> 或 <img src="./abc" />
# ".." -- 代表上一层目录,相对路径. 如:<a href="../abc">文本</a> 或 <img src="../abc" />
# "../../" -- 代表的是上一层目录的上一层目录,相对路径. 如:<img src="../../abc" />
# "/" -- 代表根目录,绝对路径. 如:<a href="/abc">文本</a> 或 <img src="/abc" />
# "D:/abc/" -- 代表根目录,绝对路径.

with open('./data.txt', 'r') as file:
    # 带参read,只读5个字符
    print(file.read(5))
    # 打开文档从第6个字符开始读
    # file.seek(6)
    # print(file.read(6))
    # 打印当前文件是否可读.成功为True 反之False
    print(file.readable())
    # 打印当前文件是否可写.成功为True 反之False
    print(file.writable())
    # 读取所有行
    datas = file.readlines()
    # datas是列表
    print(type(datas))
    print(datas)
    # 使用遍历列表的方法读取
    for data in datas:
        # 打印读取的每一行  文本文档默认有\n换行符,我们使用replace将换行符替换为空字符串
        print(data.replace('\n', ''))

常用配置文件的读取

1
2
3
4
5
6
7
8
9
mysql.config:
    
# this is database config file
db_Ip=127.0.0.1
db_Port=3306
db_Name=test
db_User=root
db_Password=root
# config end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
MysqlConfig.py:
    

ConfigData = {}

with open('./mysql.config', 'r') as file:
    # 读取所有行
    datas = file.readlines()
    for data in datas:
        # 如果数据为#开头则表示为注释,不进行读取
        if data.startswith('#'):
            continue
        key = data.split('=')[0]
        value = data.split('=')[1].replace('\n', '')
        ConfigData[key] = value


if __name__ == '__main__':
    print(ConfigData)
1
2
3
4
5
6
7
8
9
10
11
test.py
# 如果想从其他文件中引入MysqlConfig可以使用引入方式
#引入ch15文件夹下的MysqlConfig.py文件中的MysqlConfig变量
from ch15.MysqlConfig import ConfigData

print(ConfigData)
print('数据库IP:', ConfigData['db_Ip'])
print('数据库端口:', ConfigData['db_Port'])
print('数据表名称:', ConfigData['db_Name'])
print('数据库用户:', ConfigData['db_User'])
print('数据库密码:', ConfigData['db_Password'])

文件的写入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 默认的write是不会换行的
# w:write 覆盖,每次写入都会清空后再写入
# a:add   追加
with open('./data_Write.txt', 'w') as file:
    # #单行写入
    # data = 'hello python'
    # file.write(data)
    # data = 'i am JiangJiYue'
    # file.write(data)
    # 多行写入
    datas = ['hello python', 'i am JiangJiYue', 'jiangjiyue.github.io']
    # 使用推导式在每一行后面添加换行符但是会造成总是在最后空一行
    file.writelines([data+'\n' for data in datas])
    # 字符串连接方式,不会造成最后总是空一行
    # file.writelines('\n'.join(datas))

with open('./data_Write.txt', 'a') as file:
    # #单行写入
    # data = 'hello python'
    # file.write(data)
    # data = 'i am JiangJiYue'
    # file.write(data)
    # 多行写入
    datas = ['hello python', 'i am JiangJiYue', 'jiangjiyue.github.io']
    # 使用推导式在每一行后面添加换行符但是会造成总是在最后空一行
    file.writelines([data+'\n' for data in datas])

字符编码问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# 解决中文编码问题

# 机写机读没问题
with open('encoding.txt', 'w') as file:
    file.write('人生苦短,我用Python')


with open('encoding.txt', 'r') as file:
    print(file.readline())

# 手写机读就会出现编码错误

with open('encoding_cn.txt', 'r') as file:
    print(file.readline())

目录及其他操作

os常用方法

方法 描述
os.access(path, mode) 检验权限模式
os.chdir(path) 改变当前工作目录
os.chflags(path, flags) 设置路径的标记为数字标记.
os.chmod(path, mode) 更改权限
os.chown(path, uid, gid) 更改文件所有者
os.chroot(path) 改变当前进程的根目录
os.close(fd) 关闭文件描述符 fd
os.closerange(fd_low, fd_high) 关闭所有文件描述符,从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
os.dup(fd) 复制文件描述符 fd
os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2
os.fchdir(fd) 通过文件描述符改变当前工作目录
os.fchmod(fd, mode) 改变一个文件的访问权限,该文件由参数fd指定,参数mode是Unix下的文件访问权限.
os.fchown(fd, uid, gid) 修改一个文件的所有权,这个函数修改一个文件的用户ID和用户组ID,该文件由文件描述符fd指定.
os.fdatasync(fd) 强制将文件写入磁盘,该文件由文件描述符fd指定,但是不强制更新文件的状态信息.
[os.fdopen(fd[, mode[, bufsize]])](https://www.runoob.com/python/os-fdopen.html) 通过文件描述符 fd 创建一个文件对象,并返回这个文件对象
os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息.name为检索的系统配置的值,它也许是一个定义系统值的字符串,这些名字在很多标准中指定(POSIX.1, Unix 95, Unix 98, 和其它).
os.fstat(fd) 返回文件描述符fd的状态,像stat().
os.fstatvfs(fd) 返回包含文件描述符fd的文件的文件系统的信息,像 statvfs()
os.fsync(fd) 强制将文件描述符为fd的文件写入硬盘.
os.ftruncate(fd, length) 裁剪文件描述符fd对应的文件, 所以它最大不能超过文件大小.
os.getcwd() 返回当前工作目录
os.getcwdu() 返回一个当前工作目录的Unicode对象
os.isatty(fd) 如果文件描述符fd是打开的,同时与tty(-like)设备相连,则返回true, 否则False.
os.lchflags(path, flags) 设置路径的标记为数字标记,类似 chflags(),但是没有软链接
os.lchmod(path, mode) 修改连接文件权限
os.lchown(path, uid, gid) 更改文件所有者,类似 chown,但是不追踪链接.
os.link(src, dst) 创建硬链接,名为参数 dst,指向参数 src
os.listdir(path) 返回path指定的文件夹包含的文件或文件夹的名字的列表.
os.lseek(fd, pos, how) 设置文件描述符 fd当前位置为pos, how方式修改: SEEK_SET 或者 0 设置从文件开始的计算的pos; SEEK_CUR或者 1 则从当前位置计算; os.SEEK_END或者2则从文件尾部开始. 在unix,Windows中有效
os.lstat(path) 像stat(),但是没有软链接
os.major(device) 从原始的设备号中提取设备major号码 (使用stat中的st_dev或者st_rdev field).
os.makedev(major, minor) 以major和minor设备号组成一个原始设备号
os.makedirs(path,mode) 递归文件夹创建函数.像mkdir(), 但创建的所有intermediate-level文件夹需要包含子文件夹.
os.minor(device) 从原始的设备号中提取设备minor号码 (使用stat中的st_dev或者st_rdev field ).
os.mkdir(path,[mode]) 以数字mode的mode创建一个名为path的文件夹.默认的 mode 是 0777 (八进制).
os.mkfifo(path,[mode]) 创建命名管道,mode 为数字,默认为 0666 (八进制)
os.mknod(filename,mode=0600,device) 创建一个名为filename文件系统节点(文件,设备特别文件或者命名pipe).
os.open(file,flags,[mode]) 打开一个文件,并且设置需要的打开选项,mode参数是可选的
os.openpty() 打开一个新的伪终端对.返回 pty 和 tty的文件描述符.
os.pathconf(path, name) 返回相关文件的系统配置信息.
os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
[os.popen(command[, mode[, bufsize]])](https://www.runoob.com/python/os-popen.html) 从一个 command 打开一个管道
os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节,返回包含读取字节的字符串,文件描述符 fd对应文件已达到结尾, 返回一个空字符串.
os.readlink(path) 返回软链接所指向的文件
os.remove(path) 删除路径为path的文件.如果path 是一个文件夹,将抛出OSError; 查看下面的rmdir()删除一个 directory.
os.removedirs(path) 递归删除目录.
os.rename(src, dst) 重命名文件或目录,从 src 到 dst
os.renames(old, new) 递归地对目录进行更名,也可以对文件进行更名.
os.rmdir(path) 删除path指定的空目录,如果目录非空,则抛出一个OSError异常.
os.stat(path) 获取path指定的路径的信息,功能等同于C API中的stat()系统调用.
os.stat_float_times(newvalue) 决定stat_result是否以float对象显示时间戳
os.statvfs(path) 获取指定路径的文件系统统计信息
os.symlink(src, dst) 创建一个软链接
os.tcgetpgrp(fd) 返回与终端fd(一个由os.open()返回的打开的文件描述符)关联的进程组
os.tcsetpgrp(fd, pg) 设置与终端fd(一个由os.open()返回的打开的文件描述符)关联的进程组为pg.
[os.tempnam([dir[, prefix]])](https://www.runoob.com/python/os-tempnam.html) 返回唯一的路径名用于创建临时文件.
os.tmpfile() 返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口,没有文件描述符,将会自动删除.
os.tmpnam() 为创建一个临时文件返回一个唯一的路径
os.ttyname(fd) 返回一个字符串,它表示与文件描述符fd 关联的终端设备.如果fd 没有与终端设备关联,则引发一个异常.
os.unlink(path) 删除文件路径
os.utime(path, times) 返回指定的path文件的访问和修改的时间.
[os.walk(top[, topdown=True[, onerror=None[, followlinks=False]]])](https://www.runoob.com/python/os-walk.html
) 输出在文件夹中的文件名通过在树中游走,向上或者向下.
os.write(fd, str) 写入字符串到文件描述符 fd中. 返回实际写入的字符串长度

os.path常用方法:

方法 说明
os.path.abspath(path) 返回绝对路径
os.path.basename(path) 返回文件名
os.path.commonprefix(list) 返回list(多个路径)中,所有path共有的最长的路径
os.path.dirname(path) 返回文件路径
os.path.exists(path) 如果路径 path 存在,返回 True;如果路径 path 不存在,返回 False.
os.path.lexists 路径存在则返回True,路径损坏也返回True
os.path.expanduser(path) 把path中包含的””和”user”转换成用户目录
os.path.expandvars(path) 根据环境变量的值替换path中包含的”{name}”
os.path.getatime(path) 返回最近访问时间(浮点型秒数)
os.path.getmtime(path) 返回最近文件修改时间
os.path.getctime(path) 返回文件 path 创建时间
os.path.getsize(path) 返回文件大小,如果文件不存在就返回错误
os.path.isabs(path) 判断是否为绝对路径
os.path.isfile(path) 判断路径是否为文件
os.path.isdir(path) 判断路径是否为目录
os.path.islink(path) 判断路径是否为链接
os.path.ismount(path) 判断路径是否为挂载点
os.path.join(path1[, path2[, …]]) 把目录和文件名合成一个路径
os.path.normcase(path) 转换path的大小写和斜杠
os.path.normpath(path) 规范path字符串形式
os.path.realpath(path) 返回path的真实路径
os.path.relpath(path[, start]) 从start开始计算相对路径
os.path.samefile(path1, path2) 判断目录或文件是否相同
os.path.sameopenfile(fp1, fp2) 判断fp1和fp2是否指向同一文件
os.path.samestat(stat1, stat2) 判断stat tuple stat1和stat2是否指向同一个文件
os.path.split(path) 把路径分割成 dirname 和 basename,返回一个元组
os.path.splitdrive(path) 一般用在 windows 下,返回驱动器名和路径组成的元组
os.path.splitext(path) 分割路径,返回路径名和文件扩展名的元组
os.path.splitunc(path) 把路径分割为加载点与文件
os.path.walk(path, visit, arg) 遍历path,进入每个目录都调用visit函数,visit函数必须有3个参数(arg, dirname, names),dirname表示当前目录的目录名,names代表当前目录下的所有文件名,args则为walk的第三个参数
os.path.supports_unicode_filenames 设置是否支持unicode路径名 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
# -*- coding:utf-8 -*-
"""
作者:kill3r
日期:2022年06月10日
Blog:jiangjiyue.github.io
"""

import os
import shutil

# 判断data.txt是否存在
print(os.path.exists('data.txt'))
# 获取当前路径
print(os.getcwd())

dirpath = 'test'

# 删除文件,删除不存在的文件会报错
os.remove('1.txt')

# 如果目录不存在则创建目录
if not os.path.exists(dirpath):
    # 创建test目录
    # os.mkdir不能创建多级目录,
    # print(os.mkdir(dirpath))
    # 创建多级目录
    os.makedirs(r'd:\test3\test')
else:
    # 只能删除空目录,如果非空请使用shutil.rmtree
    os.rmdir(dirpath)

if os.path.exists('test3'):
    # 删除非空目录
    print('非空目录删除:', shutil.rmtree('test3'))

datas = os.listdir((os.getcwd()))
for data in datas:
    print(data)
# 另一种强大遍历目录和文件的方法
# 强烈推荐
for files in os.walk(os.getcwd()):
    # 可以使用序列解包
    print(files)

for dirpath, subdirs, files in os.walk(os.getcwd()):
    for name in subdirs:
        print('目录:', os.path.join(dirpath,name))
    for name in files:
        print('文件', os.path.join(dirpath, name))

数据库操作

数据库DataBase

Database是按照数据结构来组织、存储和管理数据的仓库,它产生于距今六十多年前,随着信息技术和市场的发展,特别是二十世纪九十年代以后,数据管理不再仅仅是存储和管理数据,而转变成用户所需要的各种数据管理的方式.数据库有很多种类型,从最简单的存储有各种数据的表格到能够进行海量数据存储的大型数据库系统都在各个方面得到了广泛的应用.

在信息化社会,充分有效地管理和利用各类信息资源,是进行科学研究和决策管理的前提条件.数据库技术是管理信息系统、办公自动化系统、决策支持系统等各类信息系统的核心部分,是进行科学研究和决策管理的重要技术手段.

https://jiangjiyue.github.io/categories/%E5%AE%89%E5%85%A8%E8%BF%90%E7%BB%B4/%E6%95%B0%E6%8D%AE%E5%BA%93/
https://jiangjiyue.github.io/categories/%E5%AE%89%E5%85%A8%E8%BF%90%E7%BB%B4/%E6%95%B0%E6%8D%AE%E5%BA%93/

数据库编程接口

1
2
# Python DataBase API 2.0
# 连接、事务(提交、回滚)、游标

SQLite

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
# -*- coding:utf-8 -*-
"""
作者:kali
日期:2022年06月10日
Blog:jiangjiyue.github.io
"""

# sqlite
import sqlite3


# 1.连接数据库 2.拿到游标 3.执行sql 4.关闭游标 5.关闭数据库的连接
def createtable():
    # 连接数据库
    conn = sqlite3.connect('sqlite.db')
    # 拿到游标
    cursor = conn.cursor()
    # 执行sql
    # 创建数据表,只需运行一次
    sql_str = 'create table sqlite (id int(11) primary key ,name varchar(50))'
    cursor.execute(sql_str)
    # 关闭游标&连接
    cursor.close()
    conn.close()


def insertsqlite():
    # 连接数据库
    conn = sqlite3.connect('sqlite.db')
    # 拿到游标
    cursor = conn.cursor()
    # 执行sql
    sql_str = 'insert into sqlite (id,name) values(1,"kali")'
    cursor.execute(sql_str)
    # 关闭游标&连接
    cursor.close()
    # 数据库提交,才会写入,创建表不需要conn.commit
    conn.commit()
    conn.close()


def selectsqlite():
    # 连接数据库
    conn = sqlite3.connect('sqlite.db')
    # 拿到游标
    cursor = conn.cursor()
    sql_str = 'select * from sqlite'
    cursor.execute(sql_str)
    # 获取结果
    """
    fetchall 获取所有数据 return list
    fetchone 获取一行数据
    """
    result = cursor.fetchone()
    print(result)
    cursor.close()
    conn.commit()
    conn.close()


def updatesqlite():
    # 连接数据库
    conn = sqlite3.connect('sqlite.db')
    # 拿到游标
    cursor = conn.cursor()
    sql_str = 'update sqlite set name="kali" where id = 1'
    cursor.execute(sql_str)
    cursor.close()
    conn.commit()
    conn.close()

def delsqlite():
    # 连接数据库
    conn = sqlite3.connect('sqlite.db')
    # 拿到游标
    cursor = conn.cursor()
    sql_str = 'delete from sqlite where id = 1'
    cursor.execute(sql_str)
    cursor.close()
    conn.commit()
    conn.close()


# 数据捕获错误实例
def caputeerror():
    try:
        # 连接数据库
        conn = sqlite3.connect('sqlite.db')
        # 拿到游标
        cursor = conn.cursor()
        # 执行sql
        sql_str = 'insert into sqlite (id,name) values(1,"kali")'
        cursor.execute(sql_str)
    except Exception as e:
        # 事务回滚
        conn.rollback()
    else:
        # 数据库提交,才会写入,创建表不需要conn.commit
        conn.commit()
    finally:
        # 关闭游标&连接
        cursor.close()
        conn.close()


if __name__ == '__main__':
    # 查询数据函数
    selectsqlite()
    # 更新数据函数
    updatesqlite()
    selectsqlite()
    delsqlite()
    selectsqlite()

MySql

pip install pymysql安装mysql扩展

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
# -*- coding:utf-8 -*-
"""
作者:kali
日期:2022年06月10日
Blog:jiangjiyue.github.io
"""

import pymysql

def selectmysql():
    db_ip = '192.168.1.10'
    db_port = 3306
    db_name = 'pycourse'
    db_user = 'pycourse'
    db_password = 'pycourse'
    # 连接数据库
    conn = pymysql.connect(host=db_ip,port=db_port,database=db_name,user=db_user,password=db_password)
    # 拿到游标
    cursor = conn.cursor()
    sql_str = 'select * from pycourse'
    cursor.execute(sql_str)
    # 获取结果
    """
    fetchall 获取所有数据 return list
    fetchone 获取一行数据
    """
    result = cursor.fetchone()
    print(result)
    cursor.close()
    conn.commit()
    conn.close()


if __name__ == '__main__':
    selectmysql()

GUI图形用户接口

GUI简介

图形用户界面(Graphical User Interface,简称 GUI,又称图形用户接口)是指采用图形方式显示的计算机操作用户界面

图形用户界面是一种人与计算机通信的界面显示格式,允许用户使用鼠标等输入设备操纵屏幕上的图标或菜单选项,以选择命令、调用文件、启动程序或执行其它一些日常任务.与通过键盘输入文本或字符命令来完成例行任务的字符界面相比,图形用户界面有许多优点.图形用户界面由窗口、下拉菜单、对话框及其相应的控制机制构成,在各种新式应用程序中都是标准化的,即相同的操作总是以同样的方式来完成,在图形用户界面,用户看到和操作的都是图形对象,应用的是计算机图形学的技术.

https://sunhwee.com/posts/80fa3a85.html
https://sunhwee.com/posts/80fa3a85.html

Tkinter的基本用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# tk简介
# -*- coding:utf-8 -*-
"""
作者:kali
日期:2022年06月11日
Blog:jiangjiyue.github.io
"""

from tkinter import *

# 实例化对象
window = Tk()

# 窗口标题
window.title('欢迎来到tk')

# 宽度x高度+x偏移量+y偏移量
window.geometry('400x200+400+200')

window.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# Label
# -*- coding:utf-8 -*-
"""
作者:kali
日期:2022年06月11日
Blog:jiangjiyue.github.io
"""

from tkinter import *

window = Tk()

window.title('控件')
window.geometry('600x400+400+200')


# 控件一 标签 Label
# height单位为行 width单位为字符
inputLabel = Label(window, text='人生苦短,我用Python', bg='red', font='微软雅黑 12 normal', height=2,)
inputLabel.pack(padx=5, pady=10)

inputLabel2 = Label(window, text='人生苦短,我用Python2', bg='lightyellow', font='微软雅黑 12 normal', height=2,)
inputLabel2.pack(padx=5, pady=10)

# 标签水平填充 fill=X
inputLabel3 = Label(window, text='标签水平方向填充', bg='red', font='微软雅黑 12 normal', height=2,)
inputLabel3.pack(padx=5, pady=10, fill=X)

# 标签水平填充+垂直填充 fill=BOTH, expand=True
inputLabel3 = Label(window, text='水平填充+垂直填充', bg='lightgreen', font='微软雅黑 12 normal', height=2,)
inputLabel3.pack(padx=5, pady=10, fill=BOTH, expand=True)


window.mainloop()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# Input
# -*- coding:utf-8 -*-
"""
作者:kali
日期:2022年06月11日
Blog:jiangjiyue.github.io
"""

from tkinter import *

window = Tk()


def test_btn():
    outputVar.set(inputVar.get())
    print(inputVar.get())


window.title('控件')
window.geometry('600x400+400+200')

# 容器 布局方法 pack() grid() place()
topFrame = Frame()

# height单位为行 width单位为字符
inputLabel = Label(topFrame, text='请输入网址:', )
inputLabel.pack(side=LEFT, padx=5)

inputVar = StringVar()
inputEntry = Entry(topFrame, textvariable=inputVar)
inputEntry.pack(side=LEFT, padx=10)

inputButton = Button(topFrame, text='按钮', command=test_btn)
inputButton.pack(side=LEFT, pady=10)

topFrame.pack(pady=10)

outputVar = StringVar()
outputLabel = Label(window, textvariable=outputVar, fg='green')
outputLabel.pack()

window.mainloop()

Socket网络编程

Socket套接字

套接字(Socket),就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象.一个套接字就是网络上进程通信的一端,提供了应用层进程利用网络协议交换数据的机制.从所处的地位来讲,套接字上联应用进程,下联网络协议栈,是应用程序通过网络协议进行通信的接口,是应用程序与网络协议栈进行交互的接口

socket模块的应用

Tcp使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# -*- coding:utf-8 -*-
"""
一对一模式
PyNmae:socketServer
作者:kali
日期:2022年06月11日
Blog:jiangjiyue.github.io
"""

import socket

hostAddress = ('127.0.0.1', 8888)
# 默认参数创建sk 使用Ipv4&TCP协议
sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 绑定IP地址&Prot
sk.bind(hostAddress)
# 监听
sk.listen(5)
print("启动socket服务,等待客户端连接...")
# 阻塞 接收客户端的连接
conn, clientAddress = sk.accept()
while True:
    # 接收客户端发来的信息(bytes)需要解码 .decode()解码接收到的信息
    data = conn.recv(1024).decode()
    if data:
        print('接收到客户端 %s 发送来的信息: %s' % (clientAddress, data))
        # 将接收到的数据全部转换为大写并返回给客户端
        res = data.upper()
        # res为str需要转换为bytes
        conn.sendall(res.encode())
    if data == 'exit':
        print('客户端主动断开连接')
        break

# 关闭socket
conn.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# -*- coding:utf-8 -*-
"""
PyName:socketClient
作者:kali
日期:2022年06月11日
Blog:jiangjiyue.github.io
"""



import socket

serverAddress = ('127.0.0.1', 8888)

sk = socket.socket()
# 与服务器创建连接
sk.connect(serverAddress)
while True:
    dataStr = input('发送内容:').strip()
    # 向服务器发送消息
    sk.send(dataStr.encode())
    if dataStr == 'exit':
        print('客户端退出连接')
        break
    answer = sk.recv(1024).decode()
    print('收到服务器应答: %s' % answer)

sk.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
# 并发版,可有多个客户端
# -*- coding:utf-8 -*-
"""
PyName:socketServer_upper
作者:kali
日期:2022年06月11日
Blog:jiangjiyue.github.io
"""

import socket
import threading


def deal(link, client):
    print('新线程开始处理客户端 %s:%s 的数据请求' % client)
    while True:
        # 接收客户端发来的信息(bytes)需要解码 .decode()解码接收到的信息
        data = link.recv(1024).decode()
        if data:
            print('%s 发送来的信息: %s' % (client, data))
            # 将接收到的数据全部转换为大写并返回给客户端
            res = data.upper()
            # res为str需要转换为bytes
            link.sendall(res.encode())
        if data == 'exit':
            print('%s:%s 客户端主动断开连接' % client)
            break
    # 关闭socket
    link.close()


# 并发版
hostAddress = ('127.0.0.1', 8888)
# 默认参数创建sk 使用Ipv4&TCP协议
sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 绑定IP地址&Prot
sk.bind(hostAddress)
# 监听
sk.listen(5)
print("启动socket服务,等待客户端连接...")


while True:
    # 阻塞 接收客户端的连接
    conn, clientAddress = sk.accept()
    # 多线程并发
    xd = threading.Thread(target=deal, args=(conn, clientAddress))
    xd.start()

Udp使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# -*- coding:utf-8 -*-
"""
PyName:udp_Server
作者:kali
日期:2022年06月11日17时34分
Blog:jiangjiyue.github.io
"""

import socket


hostAddress = ('127.0.0.1', 8888)
# SOCK_DGRAM使用UDP创建
sk = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sk.bind(hostAddress)
print("启动[Udp]socket服务,等待客户端连接...")
while True:
    data = sk.recv(1024).decode()
    print("Udp服务器接收到的数据:", data)
    if data == 'exit':
        print('客户端请求退出')
        break

sk.close()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# -*- coding:utf-8 -*-
"""
PyName:udp_Client
作者:kali
日期:2022年06月11日17时34分
Blog:jiangjiyue.github.io
"""


import socket


hostAddress = ('127.0.0.1', 8888)

sk = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

while True:
    dataStr = input('[Udp]发送内容:').strip()
    # 向服务器发送消息
    sk.sendto(dataStr.encode(), hostAddress)
    if dataStr == 'exit':
        print('客户端退出')
        break
sk.close()

socketserver模块的应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# socketserver模块的应用
# -*- coding:utf-8 -*-
"""
PyName:socketserver
作者:kali
日期:2022年06月11日17时14分
Blog:jiangjiyue.github.io
"""
import socketserver


class MyHandler(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            data = self.request.recv(1024).decode()
            if data == 'exit':
                print('%s:%s 客户端主动断开连接' % self.client_address)
                break
            print('%s 发送来的信息: %s' % (self.client_address, data))
            # 将接收到的数据全部转换为大写并返回给客户端
            res = data.upper()
            # res为str需要转换为bytes
            self.request.send(res.encode())
        self.request.close()


if __name__ == '__main__':
    hostAddress = ('127.0.0.1', 8888)
    server = socketserver.ThreadingTCPServer(hostAddress, MyHandler)
    print("启动socket服务,等待客户端连接...")
    server.serve_forever()

多线程

程序、进程、线程

程序 进程 线程
静态的代码
程序运行后至少创建一个进程 进行起来的代码
程序的执行实例动态的
进程占用内存资源
1个进程至少包含1个线程 程序执行流的最小单元
是CPU的可执行上下文
同一个进程中的线程共享同一内存空间,数据共享
线程数据的安全性需要保护

Python多线程应用

多线程(multithreading),是指从软件或者硬件上实现多个线程并发执行的技术.具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程,进而提升整体处理性能.具有这种能力的系统包括对称多处理机、多核心处理器以及芯片级多处理或同时多线程处理器.在一个程序中,这些独立运行的程序片段叫作”线程“(Thread),利用它编程的概念就叫作”多线程处理”

Python多线程模块-threading

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# -*- coding:utf-8 -*-
"""
threading多线程创建方式
PyName:Python从入门到精通-threading_module
作者:kali-PyCharm
日期:2022年06月12日08时49分
Blog:jiangjiyue.github.io
"""

import threading


# 第一种 继承Thread

# class MyThread(threading.Thread):
#     def __init__(self, thread_name):
#         super(MyThread, self).__init__(name=thread_name)
#
#     def run(self):
#         print('%s 在执行中' % self.name)
#
#
# # 创建线程
# for i in range(10):
#     MyThread('testThread' + str(i)).start()




# 第二种(推荐)

def show(num):
    print('当前线程: %d 在执行' % num)


for i in range(10):
    # 第一个参数是线程函数变量,第二个参数args是一个数组变量参数,如果只传递一个值,
    # 就只需要i, 如果需要传递多个参数,那么还可以继续传递下去其他的参数
    # 其中的逗号不能少,少了就不是数组了,就会出错
    t = threading.Thread(target=show, args=(i,))
    t.start()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# -*- coding:utf-8 -*-
"""
线程合并场景
PyName:Python从入门到精通-threading_eg1
作者:kali-PyCharm
日期:2022年06月12日09时49分
Blog:jiangjiyue.github.io
"""

import threading
import time


def waiting():
    print('子线程开始等待..')
    time.sleep(3)
    print('子线程等待结束')


print('主线程开始执行')
t = threading.Thread(target=waiting)
t.start()
print('主线程的其他操作')
# join等待子线程结束,主线程才会结束
t.join()
print('主线程结束')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# -*- coding:utf-8 -*-
"""
守护线程场景
PyName:Python从入门到精通-threading_eg2
作者:kali-PyCharm
日期:2022年06月12日10时08分
Blog:jiangjiyue.github.io
"""
import threading
import time


def waiting():
    print(threading.current_thread().getName() + '子线程开始等待..')
    time.sleep(3)
    print(threading.current_thread().getName() + '子线程等待结束')


print('主线程开始执行')
for i in range(3):
    t = threading.Thread(target=waiting)
    # 主线程A中,创建了子线程B,并且在主线程A中调用了B.setDaemon(),这个的意思是,把主线程A设置为守护线程,这时候,要是主线程A执行结束了,就不管子线程B是否完成,
    # 一并和主线程A退出.这就是setDaemon方法的含义,这基本和join是相反的.此外,还有个要特别注意的:必须在start() 方法调用之前设置,如果不设置为守护线程,程序会被无限挂起.
    t.setDaemon(True)
    t.start()
print('主线程结束')

线程安全与线程锁

  • 互斥锁Lock
  • RLock可重入锁
  • 信号Semaphore
  • 事件Event
  • 条件Condition
  • Barrier “阻碍”
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# -*- coding:utf-8 -*-
"""
线程安全
PyName:Python从入门到精通-threading_eg3
作者:kali-PyCharm
日期:2022年06月12日10时33分
Blog:jiangjiyue.github.io
"""

import threading
import time

number = 0
# 定义一个互斥锁
lock = threading.Lock()


def add(lk):
    # 加了global,则可以在函数内部对函数外的对象进行操作了,也可以改变它的值了
    global number
    # 加锁
    with lk:
        for _ in range(1000000):
            number += 1
        print('子线程 %s 执行结束后: number = %d ' % (threading.current_thread().getName(), number))


for i in range(2):
    threading.Thread(target=add, args=(lock,)).start()

time.sleep(3)
print('主线程结束 number = ' + str(number))

标准库

os

operation system(操作系统)的缩写,这个库就是对操作系统的封装.os模块提供了多数操作系统的功能接口函数

系统相关变量和操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
# -*- coding:utf-8 -*-
"""
PyName:Python从入门到精通-os_module
作者:kali-PyCharm
日期:2022年06月12日12时02分
Blog:jiangjiyue.github.io
"""

import os

# 系统相关的内容
print(os.name)
# 环境变量
print(os.environ)
# 查看分隔符
print(os.sep)
print(os.pathsep)


# 文件和目录操作
# 创建目录
# os.mkdir('test')
# 状态
print(os.stat('test'))
# 当前路径
print(os.getcwd())
# 重命名
# os.rename('test', 'test2')
# isabs 判断是否为绝对路径 return True And False
file = os.getcwd()+r'\os_module.py'
print(file)
print(os.path.isabs(file))
# isdir:判断目录是否存在 isfile:判断文件是否存在
# 判断文件是否存在
print(os.path.exists(file))
# getatime 最后修改时间
print(os.path.getatime(file))
# getctime 创建时间
print(os.path.getctime(file))
# 文件大小
print(os.path.getsize(file))

文件和目录相关操作

执行命令和管理进程

1
2
# os: system popen
os.system('ipconfig')

sys

“sys”即”system”,”系统”之意.该模块提供了一些接口,用于访问 Python 解释器自身使用和维护的变量,同时模块中还提供了一部分函数,可以与解释器进行比较深度的交互.

方法 描述
sys.argv() 实现从程序的外部向程序传递参数
返回的是一个列表, 第一个元素是程序文件名, 第二个元素是程序外部传入的参数
sys.path() 获取指定模块搜索路径的字符串集合, 返回的是一个列表 (表示可以使用 append或者insert)
可以将写好的模块放入某个路径下, 然后将这个路径添加到 sys.path 里面, import时就可以找到
sys.exit(n) 退出程序, 正常退出时 sys.exit(0), 其他为异常退出
一般情况下运行到主程序尾部, 解释器就正常退出了, 但如果想要中途退出, 就可以调用 sys.exit 函数
sys.version() 获取 Python 解释程序的版本信息
sys.platform() 返回操作系统平台名称
sys.maxsize() 最大的 int 值
sys.getdefaultencoding( ) 获取解释器默认编码
sys.getfilesystemencoding( ) 获取内存数据存到文件里的默认编码
sys.getrecursionlimit( ) 获取最大递归层数
sys.setrecursionlimit( ) 设置最大递归层数
sys.stdin.readline( ) 标准输入
sys.stdout.write(“xxx”) 标准输出 (相比较 print 能更好的控制输出) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# -*- coding:utf-8 -*-
"""
PyName:Python从入门到精通-sys_module
作者:kali-PyCharm
日期:2022年06月12日13时45分
Blog:jiangjiyue.github.io
"""

import sys

# 运行环境版本号
print(sys.version)
# 当前版本能够表示最大的int
print(sys.maxsize)
# python所查找的路径
print(sys.path)
# 操作系统标识(根据Python所安装来标识)
print(sys.platform)
# Python版权信息
print(sys.copyright)
# 参数
print(sys.argv)
# 默认编码
print(sys.getdefaultencoding())

random

random模块用于生成伪随机数. 真正意义上的随机数(或者随机事件)是按照实验过程中表现的分布概率随机产生的,其结果是不可预测的. 而计算机中的随机数是所谓的随机函数按照一定算法模拟产生的,其结果是确定的,是可预测的.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
# -*- coding:utf-8 -*-
"""
PyName:Python从入门到精通-random_module
作者:kali-PyCharm
日期:2022年06月12日14时23分
Blog:jiangjiyue.github.io
"""
import random
import string


def demo_random():
    # 生成随机的整数
    print(random.randint(1, 100))
    # 随机生成基数用randrange,random.randrange ([start,] stop [,step])
    print(random.randrange(1, 101, 2))

    # 生成随机的浮点数
    print(random.random())  # 范围0.0-1.0
    # 指定范围生成浮点数
    print(random.uniform(10.0, 11.0))

    # 非数字类型的随机抽样
    target_list = ['a', 'b', 'c', 'd', 'e', 'f']
    print(random.choice(target_list))

    # 乱序
    print(target_list)
    # random.shuffle 必须是可改变的列表,元组也不行
    # random.shuffle(target_list)
    # print(target_list)
    # 在target_list列表中随机抽取4个适用于任何元素
    print(random.sample(target_list, 4))
    print(random.sample(target_list, len(target_list)))
    print(target_list)


# 生成随机密码的字符串 字母+符号 可以指定生成字符串的位数
def random_str(length):
    # 随机生成数字和字母的位数
    num_count = random.randint(1, length / 2)
    letter_count = length - num_count
    # 生成随机列表
    num_list = [random.choice(string.digits) for _ in range(num_count)]
    letter_list = [random.choice(string.ascii_letters) for _ in range(letter_count)]
    # 列表+列表=列表
    results = num_list + letter_list
    # 乱序密码
    random.shuffle(results)
    # 将列表拼接成字符串
    result = "".join([i for i in results])
    return result


if __name__ == '__main__':
    print(random_str(10))

time

time模块中三种时间表示方式

  • 时间戳
  • 结构化时间对象
  • 格式化时间字符串
    格式符 说明
    %a 星期的英文单词的缩写:如星期一, 则返回 Mon
    %A 星期的英文单词的全拼:如星期一,返回 Monday
    %b 月份的英文单词的缩写:如一月, 则返回 Jan
    %B 月份的引文单词的缩写:如一月, 则返回 January
    %c 返回datetime
    的字符串表示,如03/08/15 23:01:26
    %d 返回的是当前时间是当前月的第几天
    %f 微秒的表示: 范围: [0,999999]
    %H 以24小时制表示当前小时
    %I 以12小时制表示当前小时
    %j 返回 当天是当年的第几天 范围[001,366]
    %m 返回月份 范围[0,12]
    %M 返回分钟数 范围 [0,59]
    %P 返回是上午还是下午–AM
    or PM
    %S 返回秒数 范围 [0,61]…手册说明的
    %U 返回当周是当年的第几周 以周日为第一天
    %W 返回当周是当年的第几周 以周一为第一天
    %w 当天在当周的天数,范围为[0, 6],6表示星期天
    %x 日期的字符串表示 :03/08/15
    %X 时间的字符串表示 :23:22:08
    %y 两个数字表示的年份 15
    %Y 四个数字表示的年份 2015
    %z 与utc时间的间隔 (如果是本地时间,返回空字符串)
    %Z 时区名称(如果是本地时间,返回空字符串) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# -*- coding:utf-8 -*-
"""
PyName:Python从入门到精通-time_module
作者:kali-PyCharm
日期:2022年06月12日16时13分
Blog:jiangjiyue.github.io
"""
import time

# 时间戳 1970年1月1日 0:0 到指定时间的间隔
# 打印当前的时间戳
print(time.time())

# 结构化时间对象 对象的属性是只读的
st = time.localtime()
print(type(st))
# 本质是一个tuple 使用索引的方式
print('今天是{}年-{:02d}月-{:02d}日'.format(st[0], st[1], st[2]))
print('今天是星期{}'.format(st.tm_wday + 1))

# 格式化时间字符串
print(time.ctime())
# time.strftime(时间格式) '%Y-%m-%d %H:%M:%S'
print(time.strftime('%Y年%m月%d日 %H时:%M分:%S秒'))
print(time.strftime('%Y-%m-%d %H:%M:%S'))

# # sleep 让程序睡一会~
# t1 = time.time()
# print('sleep start')
# time.sleep(3)
# print('sleep end')
# t2 = time.time()
# print('执行了{:.3f}秒'.format(t2 - t1))
print('\n', end='')


# 三种格式之间的转换

print('时间戳 --> 结构化对象')
# UTC时间
print(time.gmtime())
print(time.gmtime(time.time() - 3600))
# local
print(time.localtime())
print(time.localtime(time.time() - 3600))
print('\n', end='')
print('结构化对象 --> 时间戳')
print(time.mktime(time.localtime()))
print('\n', end='')
print('结构化对象 --> 格式化时间字符串')
# time.strftime(format,str) 参数二为结构化对象
print(time.localtime())
print(time.strftime('%Y年%m月%d日 %H时:%M分:%S秒', time.localtime()))

print('\n', end='')
print('格式化的字符串 --> 结构化时间对象')
# time.strptime(str,format)
strtime = '2022-06-12 16:40:20'
print(time.strptime(strtime, '%Y-%m-%d %H:%M:%S'))
许可协议

本文由 kill3r 原创,采用 署名-非商业性使用-相同方式共享 4.0 国际 许可协议，转载请注明出处。

分享文章

快来参与讨论吧~