Python基础笔记

最新推荐文章于 2024-06-14 09:50:01 发布
最新推荐文章于 2024-06-14 09:50:01 发布
阅读量233 收藏
点赞数
分类专栏： 后端语言 文章标签： python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30258495/article/details/129903728
版权

弱类型语言

python基础

安装环境

百度

注意点❗❗

  1. 整数除以整数结果为浮点数
  2. 整数与浮点数运算结果为浮点数
  3. 关系运算符可以连用1<6<5 # False
  4. 短路概念改叫惰性求值
  5. 不支持++和--
  6. 导入是：from 模块 import 名字 as 别名
  7. true与false变为True与False
  8. 不支持三目运算符?:,但可以实现
a = 3
b = a if == 3 else 9
  1. 函数内可以访问全局变量，但不能更新(修改)其值，除非变量前加关键字
  2. + 只能拼接字符串

python在内存中的存储机制

  1. 因为是动态语言，python中的所有变量内容都存在堆heap中，而变量名只是堆中内容的引用，存放在栈stack中，便于用户去间接操作堆中的数据
  2. 对比javascript，基本数据类型，例如数值、字符串、布尔值，直接存在于栈内；而复合数据类型，例如array、object，存在于堆内，栈内存放的是堆地址的引用
  3. python采用名字绑定方式节约内存；不可变类型值一样，二者地址值一样，指向内存中同一个数，改变变量值，会重新给变量地址值，不改变其他数据
a = 1
b = 1
print(id(a) == id(b)) # True
b = 2
print(id(a) == id(b)) # False

js中这样地址值是不同的

不可变类型可变类型
int float string bytes tuplelist dict set

输出语句

print('xz') # 默认换行
print('xz',end='') # 不换行

注释

#单行
'''多
行'''

声明变量

i = 1
f = 1.3
b = true
s = 'string'

基本数据类型

int

float

bool

string

  • ''与""都可

字节串bytes

bytes是一个类

  • 字符串由若干个字符组成，以字符为单位进行操作；字节串由若干个字节组成，以字节为单位进行操作。
  • 字节串和字符串除了操作的数据单元不同之外，它们支持的所有方法都基本相同。
  • 字节串和字符串都是不可变序列，不能随意增加和删除数据。
buffer = b'abcdefghijklmn'
print(buffer, type(buffer), len(buffer))
print(buffer[0:5:2])
# b'abcdefghijklmn' <class 'bytes'> 14
# b'ace'

buffer = b'\x11\xff\x77'
print('%x' % buffer[1])
# ff

buffer = bytes([i + 0x10 for i in range(10)])
print(buffer)
# b'\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19'

x = 65534
bufferLittle = x.to_bytes(2, 'little')
bufferBig = x.to_bytes(2, 'big')
print(bufferLittle)
print(bufferBig)

y = int.from_bytes(b'\xfe\xff', 'little')
print(y)
'''
b'\xfe\xff'
b'\xff\xfe'
65534
'''

类型转换

  • int()转换为int类型
  • float()转换为float类型
  • str()转换为string类型
  • tuple()转换为元组
  • list()转换为列表
  • set()转换为集合

断言assert

assert 表达式 # 等价于下边语句
if 表达式 == true:
   pass
else:
   assertError

条件控制

  • if
if 条件:
	语句体
else:
	语句体

# 如果条件为True，a=1,否则为0
a = 1 if 条件 else 0

循环

  • range(start,end,step)
x = range(5) # x为[0, 1, 2, 3, 4]
x = range(0, 3) # x = [0, 1, 2]
x = range(0, 10, 3) # x = [0, 3, 6, 9]
# range()会生成列表
  • for
x = ['x', 'u', 'z', 'z']

for i in x:
   # i 为值

for i in range(10):
   # i 为值
   pass

for item in enumerate(x):
   # item为(index, value)格式元组

for i,value in enumerate(x):
   # i 为下标
   # value 为值
   pass

for i in iter(x):
   # i 为值
   pass

列表

  • 可以逆序查找
    • list[-1]最后一个元素
  • 切片list[0:2]
  • 删除指定下标元素del list[2]
  • len([1,2,3])查询列表长度
  • [1,2,3] + [4,5,6] 结果[1, 2, 3, 4, 5, 6]
  • [1] * 3 结果 [1, 1, 1]
  • 支持推导式
  • 列表比较
# 导入 operator 模块
import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print(operator.eq(a, b))  # False
print(operator.eq(c, b))  # True
print(b == c)  # True
print(id(b) == id(c))  # False
  • 列表排序sort()
    • 传递给key参数的是一个函数，它指定可迭代对象中的每一个元素来按照该函数进行排序
a = ['xx', 'xxx', 'xxxxx', 'x', 'xxxx']
a.sort(key = len, reverse = True)

元组

  1. 只读
  2. Python 的元组与列表类似，不同之处在于元组的元素不能修改
  3. 元组使用小括号 ( )，列表使用方括号 [ ]
  4. 元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
  5. 创建只有一个元素的元组
# 必须加,
a = (1,) # `a = (1)`不行
  1. 元组的拷贝
import copy
a = (1, 2)
# 第一种
b = copy.copy(a)
# 第二种
c = a * 1
# 第三种：深拷贝
e = copy.deepcopy()
  1. 不支持推导式
a = (i for i in range(10)) # 报错
# 以下两种写法都可
a = tuple(i for in range(10))
a = tuple([i for in range(10)])
  1. 可切片

字典

  1. 无序可变
  2. 可迭代
  3. 键值可以是数字,如dict = {9:9}
#创建方式
d = {'name':'xz','age':12,10:10}
d2 = dict()
#访问数据
d['name']
  1. 重复键名后面的值会覆盖前面同名值
  2. 元组可以当键
  3. 其他类型转换为字典
dt = dict([(1,2),(3,4)]) #可以
dt = dict([{1,2},{3,4}]) #可以
dt = dict([[1,2],[3,4]]) #可以
dt = dict(((1,2),(3,4))) #可以
dt = dict(({1,2},{3,4})) #可以
dt = dict(([1,2],[3,4])) #可以
dt = dict({(1,2),(3,4)}) #可以
dt = dict({{1,2},{3,4}}) # 不可以 集合里的值必须可哈希
dt = dict({[1,2],[3,4]}) # 不可以 集合里的值必须可哈希
  1. 视图对象
1. dict.keys()、dict.values() 和 dict.items() 返回的都是视图对象（ view objects），提供了字典实体的动态视图，这就意味着字典改变，视图也会跟着变化。

2. 视图对象不是列表，不支持索引，可以使用 list() 来转换为列表。

3. 我们不能对视图对象进行任何的修改，因为字典的视图对象都是只读的。

集合

  1. 值不可重复且必须可哈希
  2. 可添加，可删除
  3. 无法使用索引
  4. 支持推导式
  5. 无序:集合.add('xz')不一定会添加在最后
#创建
s = set()
#赋值
s = {'x','z','1'}
  1. 集合的运算
s2 = {'3', '4', '5', '6'}
print('交集： ', s1 & s2, s1.intersection(s2))
print('并集： ', s1 | s2, s1.union(s2))
print('差集： ', s1 - s2, s1.difference(s2))
print('补集： ', s1 ^ s2, s1.symmetric_difference(s2))
  1. 不能+,*

不能用s = {}创建空集合
集合的pop方法：

如果集合中只有数字：pop删除最小数据，其他数据升序排列
如果集合中字符串：pop随机删除
如果集合中有数字有字符串：如果删除数字，删除最小数据，其他>>据升序排列
如果删除字符串，随机删除

函数

  • 传参数
    • *参数名：传入时将元组,列表解包，函数收到时说明此参数接受多个值，并把他们转换成元组赋值给此形参
def sum(a, b, *c):
 return c
print(sum(1, 2, *[3, 4, 5]))  # (3, 4, 5)
# 等价于 print(sum(1, 2, 3, 4, 5))
  • **参数名：传入时将字典解包为key=value格式参数，函数接受时说明此参数必须用关键字导入，且将其转换成字典赋值给此形参
def sum(a, b, **c):
 return c
print(sum(1, 2, a = 3, b = 4))  # 报错
#####
def sum(a, b, **c):
 return c
print(sum(1, 2, c = 3, d = 4))  # {'c': 3, 'd': 4}
# 等价于 print(sum(1, 2, **{'c': 3, 'd': 4}))
  • *：*后的参数需用关键字传入
def sum(a, b, *, c):
 return c
print(sum(1, 2, 3))  # 报错
######
def sum(a, b, *, c):
 return c
print(sum(1, 2, c = 3))  # 3
  • 匿名函数lambda
a = lambda n, m: n + m
print(a(1, 2))
#3
  • 变量的访问
    • L（Local） –> E（Enclosing） –> G（Global） –>B（Built-in） 的规则查找，即：在局部找不到，便会去局部外的局部找（例如闭包），再找不到就会去全局找，再者去内建中找。
  • 变量的修改
    • 若要修改全局变量要加global关键字，修改上一级函数作用域变量要加关键字nonlocal

不能声明后直接修改,例：global a = 3❌

b = 1
def c():
    b = 2
    def d():
        b = 3
        a = 3
        def e():
            nonlocal a
            a += 100
            print(a) # 103
            # global b = 9 # 报错
            global b
            b += 100 # 修改成功 
            def compute():
                print(b) # 101
            compute()
        e()
    d()

c()
  • 对比javascript
let a = 1
function fun1(){
    function fun2(){
 	   a++
 	   console.log(a)
    }
    fun2()
}
fun1()
//输出 2
  • 看不见的字典global()
# 全局下定义的变量其实是global()返回对象的key，value
#例：
x = 10
print(global()['x']) # 10

占位符

print('鸡 = %d'%chickens,'兔子 = %d'%rabbits)
print('鸡 = %d,兔子 = %d'%(chickens,rabbits))
--
%d, %i代表整数
%f浮点
%s字符串
%cchar
%p指针
%fL长log
%e科学计数
%g小数或科学计数。
%a,%A读入一个浮点值(仅C99有效)。
%c读入一个字符。
%d读入十进制整数。
%i读入十进制，八进制，十六进制整数。
%o读入八进制整数。
%x,%X读入十六进制整数。
%s读入一个字符串，遇空格、制表符或换行符结束。
%f,%F,%e,%E,%g,%G用来输入实数，可以用小数形式或指数形式输入。
%p读入一个指针。
%u读入一个无符号十进制整数。
%n至此已读入值的等价字符数。
%[]扫描字符集合。
%%读 % 符号

运算符

逻辑运算符

  • &&与||变成and与or

成员运算符

  • in,not in
2 in [1,2,3]#True
2 not in [1,2,3]#false

身份运算符

  • is,is not
  • 身份运算符用于比较两个对象的存储单元
  • x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True
    • id() 函数用于获取对象内存地址
a = 20
b = 20
 
if ( a is b ):
   print ("1 - a 和 b 有相同的标识")
else:
   print ("1 - a 和 b 没有相同的标识")
 
if ( id(a) == id(b) ):
   print ("2 - a 和 b 有相同的标识")
else:
   print ("2 - a 和 b 没有相同的标识")
 
# 修改变量 b 的值
b = 30
if ( a is b ):
   print ("3 - a 和 b 有相同的标识")
else:
   print ("3 - a 和 b 没有相同的标识")
 
if ( a is not b ):
   print ("4 - a 和 b 没有相同的标识")
else:
   print ("4 - a 和 b 有相同的标识")
'''
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识
'''

海象运算符:=

  • 在语句内赋值
  • 返回值为所赋的值
if (a := 10) == 10:
	print(a)

集合运算符

&|-^除了可以进行二进制运算，还可以对集合进行操作，但是不能像下面这样对列表字典元组进行操作

s1 = {'1', '2', '3', '4'}
s2 = {'3', '4', '5', '6'}
print('交集： ', s1 & s2, s1.intersection(s2))
print('并集： ', s1 | s2, s1.union(s2))
print('差集： ', s1 - s2, s1.difference(s2))
print('补集： ', s1 ^ s2, s1.symmetric_difference(s2))

语法

切片[::]

  • 多个改值a[0:2] = [1, 2] 或 1, 2 都可以
a = [1, 2, 3, 4, 5, 6, 7, 8]
print(a[:3:-1])  # 等价于print(a[7:3:-1])
print(a[:3:1])  # 等价于print(a[0:3:1])
print(a[::-1])  # 等价于print(a[7:0:-1])
print(a[-1:-3:-1])  # 等价于print(a[7:5:-1])
print(a[-1:-3:1])  # 等价于print(a[7:5:1]) 空因为他只能往两个中间取值（step为正则从左向右，反之）
'''
总结
1.当start与end都省略时，
    step为正
        start取最小值，end取最大值（下标）
    step为负
        start取最大值，end取最小值（下标）
2.step为正从右往左切，反之从左往右切
3.均是start闭end开
4.step方向必须是往start和end中间切
'''

列表推导式（语法糖）

myList = [i for i in range(10)]
上式等价于 for i in range(10):
                 myList.append(i)
myList = [i for i in range(10) if i % 2 == 0]
上式等价于 for i in range(10):
                 if i % 2 == 0:
                      myList.append(i)
# i 也可为表达式或者列表等列表可以存储的值

多行文本’‘’‘’'或"“”“”"

print('''
      xx
      xx
      ''')

格式化字符串

f'xxxxxxx{表达式}xxxxx'

序列解包

## 
a, *b = [1, 2, 3, 4]
# a是1，b是[2, 3, 4]

##
a = [1, 2, 3, 4]
def fun(i, j, *k): # 接受两个及以上参数，超过两个的放在k元组中
print(i,j,k)
fun(*a) # 将a列表解包成 1, 2, 3, 4参数传入

模块

导入源文件

  • 被导入的myFun.py文件
def sayHello():
   print('HelloWorld!!!')
  • 需要导入的test.py文件
# 第一种导入
import myFun
myFun.sayHello() # 输出 HelloWorld!!!
# 第二种导入
from myFun import sayHello
sayHello() # 输出 HelloWorld!!!
# 第三种导入
from myFun import *
sayHello() # 输出 HelloWorld!!!

name属性

  1. 每个模块都有一个__name__属性，当其值是__main__时，表明该模块自身在运行，否则是被引入

dir()

  1. 查看模块中已经定义的名字
ipmport myFun
print(dir(myFun))
'''
['__builtins__', '__cached__', '__doc__', '__file__',
 '__loader__', '__name__', '__package__', '__spec__', 
 'sayHello']
'''

输入输出

美化输出

  • repr(string) 转义转义字符
x = 'hello\npython'
iStr = str(x)
iRepr = repr(x)
print(iStr)
print(iRepr)
""" 输出
hello
python
'hello\npython'
"""
  • format()
# 顺序填充
print('xxx {} xxx {} xxx {} '.format(1, 2, 3))
# xxx 1 xxx 2 xxx 3

# 指定填充
print('xxx {0} xxx {num} xxx {1} '.format(1, 2, num = 3))
# xxx 1 xxx 3 xxx 2 

# !a (使用 ascii()), !s (使用 str()) 和 !r (使用 repr()) 将传入值格式化
print('xxx {!a} xxx {!r} xxx {num!s} '.format(1, 2, num = 3))
# xxx 1 xxx 2 xxx 3

# : 格式化
x = {'python': 1, 'c++': 2}
print('xxx {0[python]:d} xxx {0[c++]:.3f} '.format(x))
# xxx 1 xxx 2.000

# 
table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
print('{Runoob:d};{Google:d};{Taobao:d}'.format(**table)) # format(**table)相当于format(Google = 1, Runoob = 2, Taobao = 3)

'''
<：左对齐
>：右对齐
^：居中
=：在正负号（如果有的话）和数字之间填充，该对齐选项仅对数字类型有效。它可以输出类   似 +0000120 这样的字符串
'''
  • % 格式化
a = '1'
print('xx%d' % a)

输入

a, b, c = input("请输入三角形三边的长：")[:] # 输入123
print(a, b, c) # 1 2 3
a, b, c = input("请输入三角形三边的长：").split( ) # 输入1 2 3
print(a, b, c) # 1 2 3

读写文件

  • open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
    1. file: 必需，文件路径（相对或者绝对路径）。
    2. mode: 可选，文件打开模式
    3. buffering: 设置缓冲
    4. encoding: 一般使用utf8
    5. errors: 报错级别
    6. newline: 区分换行符
    7. closefd: 传入的file参数类型
    8. opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符
  • 基础用法
#写入文件
f = open('./test01.txt','w+')
f.write('hello! os\nyes!') # 会返回写入字符数；只能写入字符串
f.close()

#读取文件
f = open('./test01.txt','r+')
print(f.tell()) # 输出开始读时指针指向字节
print(f.read())
print(f.tell()) # 输出当前指针指向字节
f.close()

#读取文件第一行
f = open('./test01.txt','r')
print(f.readline())
f.close()

#将文件按行分割
f = open('./test01.txt','r')
print(f.readlines())
f.close()

#将文件指定字节长度按❗行分割，不够一行按一行算
f = open('./test01.txt','r')
print(f.readlines(2))
f.close()

'''输出
0
hello! os
yes!
15

hello! os

['hello! os\n', 'yes!']

['hello! os\n']
'''
  • f.seek()改变指针位置
  1. 改变文件指针当前的位置, 使用 f.seek(offset, from_what)。
  2. from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：
  3. seek(x,0) ： 从起始位置即文件首行首字符开始移动 x 个字符
  4. seek(x,1) ： 表示从当前位置往后移动 x 个字符
  5. seek(-x,2)：表示从文件的结尾往前移动 x 个字符

读写操作后，指针会移向最后，指针没归位再进行读写，会从指针处最后开始
操作完成一定要f.close()

  • sys.stdin/stdout/stderr重定向输入输出及报错文件
import sys
f = open('input.txt', 'w')
f.write('Alex\n')
f.write('27\n')
f.close()

fIn = open('input.txt', 'r')
sys.stdin = fIn
fOut = open('output.txt', 'w')
sys.stdout = fOut
fError = open('error.txt', 'w')
sys.stderr = fError

sName = input('what is your name?')
iAge = int(input('how old are you?'))
print('hi', sName.title(), 'you are {} years old.'.format(iAge))
fIn.close()
fOut.close()

raise Exception('ERROR INFO')
fError.close()
# 输入的数据会在input.txt文件中找
# 会输出在output.txt文件中
# 错误会报在error.txt文件中

pickle模块

import pickle
d1 = {
    'name': '姚明',
    'age': 19
}
f = open('test01.txt','wb')
pickle.dump(d1,f,1) # 将对象序列化，将d1用可读性差的字符存储在test01.txt
f.close()

f = open('./test01.txt','rb')
d2 = pickle.load(f) # 解序列化，将test01.txt中字符反转成d1
f.close()
print(d2)

类class

展示与其他语言的差别

from enum import Enum

class class01:
    def test(self):
        print('爷爷')
       
class class02:pass
class class03:pass


# 创建枚举类
# print(Gender.male) 输出：Gender.male
# print(Gender.male == Gender.test) 输出 True
# 枚举类不可在外面修改
class Gender(Enum):
    male = 0
    female = 1
    test = 0


# 创建类
class User(class01, class02, class03):  # 继承的同名方法，按引入顺序查找执行
    id = 0  # 公有属性
    __id = 10  # 私有属性__开头
    # 构造函数是__init__(),且第一个参数必须是实例对象

    def __init__(self, id):  # 构造实例时调用，且self自动传入，self也可以写this等；self 不是 python 关键字
        self.id = id

    # 在定义方法时，形参列表中的 self 关键字必须填写，用于代表类对象自身
    # 成员函数也需要用def关键字声明
    def myfun(self):
        pass

    # 私有成员函数用__开头
    def __myfun(self):
        pass

    # 重写
    def test(self):
        print('爸爸')
        # 调用父类方法
        super().test()


# 创建实例
user = User(100)
print(user.__class__ == User)  # 输出：True
# 在外部调用爷类被覆盖的方法
super(User,user).test() # 输出 爷爷
# 调用父类方法
user.test()# 输出 爸爸 爷爷

异常

try:
   raise 错误对象
except (错误类型):# 所有异常基类(Exception)
   # 捕获到错误执行语句
else:
   # 没捕获到错误执行语句
finally:
   # 总会执行语句
## raise相当于throw，抛出错误

错误类型[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mS34Ej1q-1680356886461)(null)]

预定义清理行为

# 这样执行代码，文件夹不会被关闭
for line in open("myfile.txt"):
    print(line, end="")
# 用with可以在执行完后自动关闭,遇错也会关闭
whith open("myfile.txt") as f:
   for line in f:
      print(line, end='')

内置方法

  1. zip()
    缝合可迭代对象
a = ['a', 'b', 'c']
b = ['x', 'y', 'z']
c = zip(a, b)
print(list(c))
# [('a', 'x'), ('b', 'y'), ('c', 'z')]
  1. exec() && eval()
    1. 将传入字符串当表达式执行
    2. eval()有返回值
result1 = exec('1+2+3')
result2 = eval('1+2+3')
print(result1, result2)
#None 6
  1. help(方法)
    1. 查看方法

快查方法

字符串

序号方法描述
1capitalize()将字符串的第一个字符转换为大写
2center(width, fillchar)返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
3count(str, beg= 0,end=len(string))返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
4bytes.decode(encoding=“utf-8”, errors=“strict”)Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
5encode(encoding=‘UTF-8’,errors=‘strict’)以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是’ignore’或者’replace’
6endswith(suffix, beg=0, end=len(string))检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
7expandtabs(tabsize=8)把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
8find(str, beg=0, end=len(string))检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
9index(str, beg=0, end=len(string))跟find()方法一样，只不过如果str不在字符串中会报一个异常。
10isalnum()如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False
11isalpha()如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
12isdigit()如果字符串只包含数字则返回 True 否则返回 False…
13islower()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
14isnumeric()如果字符串中只包含数字字符，则返回 True，否则返回 False
15isspace()如果字符串中只包含空白，则返回 True，否则返回 False.
16istitle()如果字符串是标题化的(见 title())则返回 True，否则返回 False
17isupper()如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
18join(seq)以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
19len(string)返回字符串长度
20ljust(width[, fillchar])返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
21lower()转换字符串中所有大写字符为小写.
22lstrip()截掉字符串左边的空格或指定字符。
23maketrans()创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24max(str)返回字符串 str 中最大的字母。
25min(str)返回字符串 str 中最小的字母。
26replace(old, new [, max])把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
27rfind(str, beg=0,end=len(string))类似于 find()函数，不过是从右边开始查找.
28rindex( str, beg=0, end=len(string))类似于 index()，不过是从右边开始.
29rjust(width,[, fillchar])返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
30rstrip()删除字符串末尾的空格或指定字符。
31split(str=“”, num=string.count(str))以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
32splitlines([keepends])按照行(‘\r’, ‘\r\n’, \n’)分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
33startswith(substr, beg=0,end=len(string))检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
34strip([chars])在字符串上执行 lstrip()和 rstrip()
35swapcase()将字符串中大写转换为小写，小写转换为大写
36title()返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
37translate(table, deletechars=“”)根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
38upper()转换字符串中的小写字母为大写
39zfill (width)返回长度为 width 的字符串，原字符串右对齐，前面填充0
40isdecimal()检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false

列表

序号方法描述
1list.append(obj)在列表末尾添加新的对象
2list.count(obj)统计某个元素在列表中出现的次数
3list.extend(seq)在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4list.index(obj)从列表中找出某个值第一个匹配项的索引位置
5list.insert(index, obj)将对象插入列表
6list.pop([index=-1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7list.remove(obj)移除列表中某个值的第一个匹配项
8list.reverse()反向列表中元素
9list.sort( key=None, reverse=False)

对原列表进行排序
10 |list.clear()|清空列表
11 |list.copy()|复制列表

字典

序号函数描述
1dict.clear()删除字典内所有元素
2dict.copy()返回一个字典的浅复制
3dict.fromkeys()创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
4dict.get(key, default=None)返回指定键的值，如果键不在字典中返回 default 设置的默认值
5key in dict如果键在字典dict里返回true，否则返回false
6dict.items()以列表返回一个视图对象
7dict.keys()返回一个视图对象
8dict.setdefault(key, default=None)和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
9dict.update(dict2)把字典dict2的键/值对更新到dict里
10dict.values()返回一个视图对象
11pop(key[,default])删除字典 key（键）所对应的值，返回被删除的值。
12pop.item()返回并删除字典中的最后一对键和值。

文件方法

序号方法及描述-
1file.close()关闭文件。关闭后文件不能再进行读写操作。
2file.flush()刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3file.fileno()返回一个整型的文件描述符(file descriptor FD 整型),可以用在如os模块的read方法等一些底层操作上。
4file.isatty()如果文件连接到一个终端设备返回 True，否则返回 False。
5file.next()Python 3 中的 File 对象不支持 next() 方法。返回文件下一行。
6file.read([size])从文件读取指定的字节数，如果未给定或为负则读取所有。
7file.readline([size])读取整行，包括 “\n” 字符。
8file.readlines([sizeint])读取所有行并返回列表，若给定sizeint>0，返回总和大约为sizeint字节的行, 实际读取值可能比 sizeint 较大, 因为需要填充缓冲区。
9file.seek(offset[, whence])移动文件读取指针到指定位置
10file.tell()返回文件当前位置。
11file.truncate([size])从文件的首行首字符开始截断，截断文件为 size 个字符，无 size 表示从当前位置截断；截断之后后面的所有字符被删除，其中 windows 系统下的换行代表2个字符大小。
12file.write(str)将字符串写入文件，返回的是写入的字符长度。
13file.writelines(sequence)向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符

open(file, mode=?

模式描述
t文本模式 (默认)。
x写模式，新建一个文件，如果该文件已存在则会报错。
b二进制模式。
+打开一个文件进行更新(可读可写)。
U通用换行模式（Python 3 不支持）。
r以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+打开一个文件用于读写。文件指针将会放在文件的开头。
rb+以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写
代码不高兴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python格式化字符串f-string概览
sunxb10的博客
07-15 24万+
简介 f-string，亦称为格式化字符串常量（formatted string literals），是Python3.6新引入的一种字符串格式化方法，该方法源于PEP 498 – Literal String Interpolation，主要目的是使格式化字符串的操作更加简便。f-string在形式上是以 f 或 F 修饰符引领的字符串（f'xxx' 或 F'xxx'），以大括号对 {} 标明...
python-字典练习题
xiangpipi88的博客
03-15 1075
python-字典练习题 标准的字典数据： dict_1 = {"age": 18, "sex": "girl"} 两字典相加 one_dict = {"name": "xp", "gender": "woman", "age": 15, "height": 165} two_list = {"character": "活泼", "hobby": "吃", "motto": "开心"} # 两个...
Python 基础 | 字典
weixin_42155937的博客
04-12 151
  字典是另一种可变容器模型，且可存储任意类型对象。可以采用{}或dict来创建，其中每个元素均包含一个键（key）和一个值（value），并以 : 分割。例如： Dict = {'Name':'Luo', 'Year':2022} 键值   字典的每个值都可以为包括字典在内的其他任一类型的数据。 字典内键是唯一的，不能重复。 获取键 Keys = Dict.keys() print(Keys) 执行结果：dict_keys([‘Name’, ‘Year’]) 获取值 Values = Di
python字节串与int、float、string互转，字节串与元组、列表、字符串互转
weixin_45746588的博客
01-13 1643
python字节串与int、float、string互转，字节串与元组、列表、字符串互转
python代码
weixin_39057744的博客
05-18 253
import sys def parse(line): newline='' for i in line: if i != ',' and i != ' ': newline+=i newline=newline[2:] data = int(newline,2) return ('{:02x}').format(data) with open(sys.argv[2],'a') as out: with open(sys.argv[1], "r") as f: # 打开文件 .
python基础知识笔记
热门推荐
qq_47541315的博客
10-01 3万+
python基础语法知识总结笔记，视频看的是b站的黑马程序员8天学会Python基础。
python基础笔记
2401_84379949的博客
05-21 486
python基础笔记大学
04-09
python基础笔记
python基础笔记1
10-29
python基础笔记第一份，很不错，这是文档，还会有代码上传
python基础笔记（markdown）
07-01
学长整理的python笔记，零基础整理的python知识点。文件为md格式，需要markdown阅读器进行阅读。
python基础笔记html.rar
10-14
python基础学习笔记，0基础学Python，Python在众多编程语言中可以说是最简单的语言了，学语言从Python开始！
Python内置函数
蜗牛的博客
02-04 270
1.标准输出函数print( ) print( )函数一次可以打印多个对象，打印对象可以是任意类型，有四个默认参数。 sep:指定多个输出对象的间隔，默认为空格 end：设定结尾，默认换行 file：要写入的文件对象，默认为标准输出控制台（sys.stdout） flush：是否立即输出缓存，默认内容不会立即被输出。 # print(sep='',end='',file='',flush='') print(3,[1,2,3],{'name':'zs'})# 一次可以打印多个对象，对象类型不同
python字符串编码测试
shareinfo2018
09-06 308
#encoding=utf8 import chardet def str_detect(str): try: print ":".join("{:02x}".format(ord(c)) for c in str) t = chardet.detect(str) print t if t['encoding']=="utf
python数据内存形式-引用与对象的认识
yeal
01-26 3157
这篇文章主要是对python中的数据进行认识，对于很多初学者来讲，其实数据的认识是最重要的，也是最容易出错的。本文结合数据与内存形态讲解python中的数据，内容包括： 引用与对象 可变数据类型与不可变数据类型 引用传递与值传递 深拷贝与浅拷贝 （id函数：你可以通过python的内置函数 id() 来查看对象的身份(identity)，这个所谓的身份其实就是 对象 的内存地址） 一、引
基于JavaScript 如何实现爬山算法以及优化方案
乐闻世界
06-10 1379
爬山算法（Hill Climbing Algorithm）是一种常见的启发式搜索算法，常用于解决优化问题。其核心思想是从一个初始状态出发，通过逐步选择使目标函数值增大的邻近状态来寻找最优解。接下来，我们将通过 JavaScript 实现一个简单的爬山算法，帮助大家理解其原理和应用。从一个初始状态开始。评估当前状态的目标函数值。在当前状态的邻居中选择一个目标函数值更大的状态。如果找到了更优的邻居，则移动到该邻居并重复步骤2和步骤3。如果没有更优的邻居，则算法结束，当前状态即为局部最优解。
2024.6.13刷题记录
最新发布
lshx4658的博客
06-14 450
当时没有想到怎么保证队内全都是窗口内的元素，答案：“当队头元素在窗口的左边的时候，弹出队头”，虽然不能保证队内一直没有窗口外的元素，但是能保证使用到的队内元素（队头）全是窗口内元素。当时是有想到这个方法的，但是以为不行，一下没转过来弯。队列储存索引而不是元素，通过储存索引使我们能够快速判断元素是否出窗口。不会，思路来自题解（
Java——简单图书管理系统
m0_74100417的博客
06-09 1559
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
python迁移数据教程
2402_85292291的博客
06-13 638
if os.path.isfile(src_item_path): dest_item_path = os.path.join(dest_folder, item) shutil.copy2(src_item_path, dest_item_path) # 如果item是目录，递归调用migrate_data函数。2. 准备源文件夹和目标文件夹： 在您的计算机上创建两个文件夹，分别为源文件夹（source_folder）和目标文件夹（destination_folder）。将您希望迁移的数据放入源文件夹。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值