提供了Python编程的基础技术教程

Python程序教程

您现在的位置是：首页 >  python学习

当前栏目

python学习

python,学习
2025-03-13 21:27:24 时间

users.pop[1] #列表删除特有

字符串本身不能修改删除//不可变类型。

不能用del删除字符串。

5. 修改（数字/布尔/字符串除外）

```python
users=['a','b',99]
users[2] = 66 #可以修改
users[0] = 'a' #可以修改
users[0][0] #不能修改

步长，默认步长为1，当步长为负数时从后往前取

name='alexalex'
val=name[0:-1:2] # 0为起始位置，-1结束位置，2为步长
print(name)
aeae
-------------------
val=name[::2] #从前到后步长为2
-------------------
val=name[-1:0:-2] #从后往前取，步长为2，答案是xlxl
val=name[::-2] #从后往前取，步长为2，答案是xlxl
-------------------
val=name[::-1] #反转，输入xela

for循环

name='alex'
for item in name : #遍历name将每个字符传递给item并打印
    print(item)

打印1到10

for i in range(1,11):  #前取后不取
	print(i)

打印1到10不打印7

for i in rang(1,11):  
	if i==7:
		continue
	print(i)

列表

len

users=["a","b","c"]
val=len(users)
print(val) #3

索引

users=["a","b","c"]
val = users[0]
print(val) #a

切片

users=["a","b","c"]
val = users[0:2] #['a', 'b']

步长

users=["a","b","c"]
val = users[0:2:2] #['a']

将输入的字符存入列表里使用.append()

.append()是在列表的最后追加一个元素

users=[]
while True :
    name = input('输入姓名：')
    users.append(name)
    print(users)
-------------------------------
users=[]
users.append('alex')
print(users)

插入.insert(n,'xxx')，在第n个元素前插入xxx

users=['a','b','c']
users.insert(0,'d')
print('users')

删除.remove(xxx)如果有两个相同的，只删除第一个

users.remove('a') #删除users里的a

.pop(n)n 是索引位置，如果不加索引位置，默认删除最后一个

delete = users.pop(0)可以将删除的数据存储在delete中，而del仅仅是删除

users.pop(0) #删除第0个

clear 清空

users.clear() #清空列表

列表的嵌套

users=['a',1,True,[12,2,'b'],[3,['alex','d'],6]]
users=[3][2] #取2
users=[4][1][0] # 取'alex'

.extend()习题：将字符出s='abc'添加到列表users中，不使用循环，()可以放元组，字符出，列表

users.extend(s)

反转 v1.reverse()

从小到大排 v1.sort(reverse=False)

从大到小排v1.sort(serverse=True)

判断敏感词

v = ['alex','我','你是谁']
if '我' in v :
    print ('包含敏感词')

元组

元组的书写规范

users=[1,2,3,4,5,6] #列表（可变类型）
users=(1,2,3,4,5,6) #元组（不可变类型）

没有独有功能，只有公共功能

公共：

索引

users=(1,2,3,"a")
print(users[3])

切片

users=(1,2,3,"a")
print(users[0:2])

步长

users=(1,2,3,"a")
print(users[0:2:2])

删除（不能删除）

修改（不能修改）

for循环

users=(1,2,3,"a")
for i in users:
    print(i)

len

users=(1,2,3,"a")
print(len(users))

特殊：元组中的元素不能被删除/修改

v1 = (11,22,33)
v1[1] = 999 #错误
v1 = 999 # 可以
----------------------
v1 = v1 = (11,22,33,(44,55,66)) # 可以嵌套
----------------------
v2 = [11,22,33,(44,55,66)]
v2[-1][1] = 99 # 错误 ，(44,55,66)里面不能修改，整体可以，因为是列表里的元素
v2[-1] = 123 # 正确
----------------------
v3 = (11,[1,2,3],22,33) #其中的[1,2,3]是元组的元素
v3[1] = 666 # 错误，[1,2,3]是元组的元素，不能修改
v3[1][2] = 123 # 可以

判断敏感词用 in 同字符串和列表一样

字典

帮助用户表示一个事物的信息（事物有多个属性）

data = {键:值,键:值,键:值}

获取值

info = {"name":'郭希文','age':21,'gender':'男'} #键值对
print(info['name'])#取值

取值，用这个也可以判断字典里是否有这个数据

info = {'k1':'v1','k2':'v2'}
n = info.get('k111',666) #'k111'是键，当能取到值时取值，当取不到时返回666，如果没设置默认返回None

.values()取值

输出所有的键/值

info = {"name":'郭希文','age':21,'gender':'男'}
for i in info.keys():
    print(i)
-----------------------------------
info = {"name":'郭希文','age':21,'gender':'男'}
# for a,b in info.items():
#	print(a,b) #输出所有的键值
for i in info.items() :
    print(i) #输出所有的键值

输出所有键和值，并让用户输入键，根据用户输入，输出对应的值

info = {"name":'郭希文','age':21,'gender':'男'}
for k,v in infor.items():
    print(k,v)
key = input('请输入键：') #'name'
print(info[key])  #info['name']

给一个空字典，请在空字典中添加数据：k1:1,k2:2,k3:3

info = {}
info['k1'] = '1'
info['k2'] = 2
info['k3'] = 3
print(info)

给一个空字典，请让用户输入：key，value，将输入的key，value添加到字典里

info = {}
k = input('请输入key:')
v = input('请输入value:')
info[k] = v
print(info)

给一个空字典，请让用户一直输入：key，value，将输入的key，value添加到字典里，直到用户输入了N，则表示不在输入

info = {}
while True :
    k = input('请输入key:')
    if k == 'N' :
        break
    v = input('请输入value:')
    info[k] = v
print(info)

给一个字符串，message = "k1|v1,k2|v2,k3|123"，转换成字典

info = {}
message = "k1|v1,k2|v2,k3|123"
for item in message.split(','):
	v1,v2 = item.split('|')
    info[v1] = v2
print(info)

数据类型嵌套，int/bool/str/list/tuple/dict

列表里边嵌套字典

字典嵌套，列表不能当键，字典不能当键#不可哈希

info = {'k1':'v1','k2':True,'k3':1,'k4':(11,22),'k5':[33,44],'k6':{'kk':'vv'},1:{'kk':'vv'},False:{'kk':'vv'},(11,2):{'kk':'vv'}}

习题创建一个用户列表，列表里放字典，首先用户输入用户名密码注册，在进行登录

users_list = []
while True:
    count = 0
    info = {'username':'','password':''}
    name = input('请输入账号:')
    if name == 'N':
        break
    pwd = input('请输入密码:')
    info['username'] = name
    info['password'] = pwd
    users_list.insert(count,info)
    count += 1
print(users_list)
print('注册成功')
---------------------------------------------
k = input('请输入用户名:')
v = input('请输入密码：')
num = len(users_list)
for i in users_list:
    num -= 1
    k1 = i['username']
    v2 = i['password']
    if k == k1 and v == v2 :
        print('登录成功')
        num = 1
        break
    else :
        continue
if num == 0 :
    print('登录失败')

删除

info = {'k1':'v1','k2':'v2'}
result = info.pop('k2')
print(info,result) #结果为{'k1':'v1'} v2
del info['k1'] #也是删除

更新

info.updata({'k3':'v3'}) #如果不存在就添加，如果键存在就更新

判断k1是否在其中？

if 'k1' in v : #默认判断的是 键

判断v2是否在其中？

方式一：

flag = '不存在'
for v in v.values():
    if v == 'v2':
        flag = '存在'
print(flag)

方式二：

if 'v2' in list(v.values()): #将值的整体强制转换为列表，再进行判断
    pass

判断k2:v2是否在其中?

value = v.get('k2')
if value == 'v2':
    print ('存在')
else:
    print ('不存在')

有序：元组，列表

无序：字典（3.6之后是有序的）

集合 set : v = {1,2,3,4}

无序，不重复的/不能通过索引删除

#v1 = set () 表示空集合

添加

v = {1,2}
v.add('a')

删除

v = {1,2,'a'}
v.discard('a')

updata，批量添加

v = {1,2,'a'}
v.updata({11,22,33})

交集

v = {1,2,'a'}
result = v.intersection({1,'a'}) #不对集合本身做操作，需要赋值
print(result)

并集

v = {1,2,'a'}
result = v.union({1,'a','b'})
print(result)

差集

v = {1,2,'a'}
result = v.difference({1,'a','b'}) #输出结果是，v中而{1,'a','b'}没有的
print(result)

对称差集

v = {1,2,'a'}
result = v.symmetric_difference({1,'a','b'})
print(result)

len()

for 循环

集合嵌套

  1. info = {1,2,3,True,'国风',None,(4,5)} #列表，字典，集合不能放在集合中，不能作为字典的 键

深浅拷贝

浅拷贝：拷贝第一次

深拷贝：拷贝所有数据（可变），有时候由于小数据池使得不可变数据地址一样

import copy

文件操作

file_object = open('log.txt',mode = 'r+',encoding='utf-8') #r+可读可写，r可读，w可写
content = file_object.read()
file_object.write('我')
file_object = open('log.txt',mode='w+',encoding='utf-8') #w，w+ ，会将文件清空，读取时需要调整光标
data = file_object.read()#读不到
print(data)
file_object.write('alex')
file_object.seek(0) #将光标移到第一个
data = file_object.read()
print(data)
file_object.close()

可读可写 'a+'，只要写光标会自动跳到最后

file_object = open('log.txt',mode = 'a+',encoding='utf-8')#光标默认在最后，读文件是从光标开始读
file_object.seek(0)
data = file_object.read()
print()
file_object.close()

r，只能读 **

w，只能写，写之前清空 **

a，只能追加 *

r+

  1. 读：默认从0的光标开始读，也可以通过seek调整光标位置
  2. 写：从光标所在的位置开始写，也可以通过seek调整光标的位置

w+

  1. 读：默认光标永远在写入的最后或0，也可以通过seek调整光标位置
  2. 写：先清空

a+

  1. 读：默认光标在最后，也可以通过seek调整光标位置，然后再去读取
  2. 写：永远写在最后
#写入实例：一般用于图片/音频/视频/未知代码
f = open('a.txt',mode='wb')
#把要写入的字符串转换成二进制
data = '我好困'
content = data.encode('utf-8') #将字符串按 utf-8编码转换成二进制
#再将二进制写入文件中
f.write(content)
f.close()
f = open('a.txt',mode='rb')
#直接读取二进制
data = f.read
f.close()
print(data)

三目运算

如果a>b的结果为真，h="变量1",如果为假，h="变量2"

h = "变量1" if a>b else "变量2"

函数

局部变量

在函数定义内声明变量的时候，它们与函数外具有相同名称的其他变量没有任何关系，即变量名称对于函数来说是 局部 的。这称为变量的 作用域 。所有变量的作用域是它们被定义的块，从它们的名称被定义的那点开始。

#局部变量
def func(x):
    print('x is', x)
    x = 2
    print('Changed local x to', x)
print('局部变量')
x = 50
func(x)
print('x is still', x)

在上面这段代码中，首先函数定义了形参x，相当于函数的局部变量。在函数调用的时候，传入了外部x，外部x值为50。在函数内部将x值改为2，改变的是局部变量x，外部x不受影响，从最后的输出结果可以验证。运行结果如下：

局部变量
x is 50
Changed local x to 2
x is still 50

如果你想要为一个定义在函数外的变量赋值，那么你就得告诉Python这个变量名不是局部的，而是 全局 的。我们使用global语句完成这一功能。没有global语句，是不可能为定义在函数外的变量赋值的。例如：

#访问外部变量
def func2():
    global x

    print('x is', x)
    x = 2 #这个x是全局变量
    print('Changed local x to', x)
print('访问外部变量')
x = 50
func2()
print('Value of x is', x)

运行结果如下：

访问外部变量
x is 50
Changed local x to 2
Value of x is 2

默认参数值

只有在形参表末尾的那些参数可以有默认参数值，即你不能在声明函数形参的时候，先声明有默认值的形参而后声明没有默认值的形参。这是因为赋给形参的值是根据位置而赋值的。例如

def func(a, b=5)

函数可以当作参数进行传递

def func (arg):
    arg()
def show ():
    print 999

func(show)

lambda表达式

lambda表达式，为了解决简单函数的情况

def func(a1,a2):
    return a1+100

func = lambda a1,a2:a1+100
#这两个是相同的效果
func1 = lambda:100 # 没有参数，返回100

func2 = lambda x1:x1*10

func3 = lambda *args ,**kwargs : 100

func4 = lambda n1,n2 : n1 if n1 > n2 else n2 #判断大小

内置函数

自定义函数

内置函数

len

open

print

range

max()

min()

sum()

abs() #计算绝对值

pow()

v = pow(2,3)
print(v)# 2**3 2的3次方

divmod() #计算出商和余数

round()

v = round (1.123,2) #保留小数点后2位，2可有可无
print (v) #1.12 有默认四舍五入

dict()

list()

tuple()

int()

str()

bool()

进制转换

bin () 将10进制转化成2进制

oct() 将10进制转换成8进制

hex() 将10进制转换成16进制

int() 将其他进制转换成10进制

v1 = '0b1101'
result = int(v1,base=2)#指定读的是二进制
print(result) #二进制转换成10进制

其他

  1. len()
  2. range()
  3. id()
  4. type()
  5. open()

编码相关

chr()，将十进制数字准换成unicode编码中对应的字符串

ord()，将unicode编码转换成十进制

生成随机数

import random
def ger_random_code(length=6):
    data = []
    for i in range(length):
        v = random.randint(65,90)
        data.append(chr(v))
    return ''.join(data)
code = ger_random_code()
print(code)

高级内置函数

map()循环每个元素（第二个参数），然后让每个元素执行函数（第一个参数），将每个函数执行的结果保存到新的列表中，并返回。

map(x,y) #第一个参数：必须是一个函数，第二个参数：必须是可迭代的类型

v1 = [11,22,33]
result = map (lambda x:x+100,v1)
print(result) #在python2中会返回[111,122,133]
print(list(result)) #python3中需要使用list转换后才能显示

filter()过滤

v1 = [11,22,'a',34]
result = filter(lambda x:True if tpye(x) == int else False,v1)#使用lambda来代替func函数
result = filter(lambda x:tpye(x) == int,v1)#更简化
print(list(result))

reduce()

import functools
v1 = [11,22,33]
def func (x,y):
    return x*y
result = functools.reduce(func,v1)
print(result)
----------------------------------
import functools
v1 = [11,22,33]
result = functools.reduce(lambda x,y:x*y,v1)
print(result)

模块

md5

import hashlib
obj = hashlib.md5()
obj.update('123'.encode('utf-8'))
result = obj.hexdigest()
print(result)

2.加盐

import hashlib
obj = hashlib.md5('qwesdsafewafewafaef123d'.encode('utf-8'))
obj.update('123'.encode('utf-8'))
result = obj.hexdigest()
print(result)

装饰器

在不改变原函数的情况下，在函数之前或者之后做操作

def func(arg):
    def inner():
        print('before')
        v = arg()
        print('after')
        return v
    return inner

def index():
    print('123')
    return '666'

index = func(index)
index()
def func(arg):
    def inner():
        print('before')
        v = arg()
        print('after')
        return v
    return inner

@func #第一步：执行func函数并将下面的函数当作参数传递。相当于：func(index)
	  #第二步：将func的返回值重新赋值给下面的函数名。index = func(index)
def index():
    print('123')
    return '666'

index()

Q.E.D.

相关文章