python基础--常用函数

常用函数

内建函数

在python里面可以直接使用的函数, 不需要使用import从其他文件里面导入

可以使用dir(__builtin__)进行查看

输入输出

print打印信息

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)
1

• objects – 复数，表示可以一次输出多个对象。输出多个对象时，需要用 , 分隔。
• sep – 用来间隔多个对象，默认值是一个空格。
• end – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串。
• file – 要写入的文件对象。
• flush – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

基本使用

可以把数据打印到终端里面

1. 可以直接打印一个变量, 里面没有数据的时候会打印一个换行
2. 里面是一个表达式的时候, 会打印这一个表达式的结果
3. 可以在里面使用逗号分割变量, 实际的打印信息会使用空格分割

格式化字符串

使用双引号里面

age = 10
print("我今年%d岁" % age)

age += 1
print("我今年%d岁" % age)

age += 1
print("我今年%d岁" % age)
1
2
3
4
5
6
7
8

传入多个数据的时候, 需要使用一个括号括起来

print("my name id %s, my age id %d id :%s" % ("jiao", 21, "1231002004"))
1

占位符

在Python中，print函数用于将内容输出到控制台。当使用print函数时，用{}来表示占位符，可以在字符串中插入变量的值。例如：

name = "Alice"
age = 30
print("My name is {} and I am {} years old.".format(name, age))
1
2
3

在上面的例子中，{}会被name和age的值替换，输出结果为"My name is Alice and I am 30 years old."

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'
1
2
3
4
5
6
7
8

print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
 
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名：{name}, 地址 {url}".format(**site))
 
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名：{0[0]}, 地址 {0[1]}".format(my_list))  # "0" 是必须的
1
2
3
4
5
6
7
8
9

class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value))  # "0" 是可选的
1
2
3
4
5

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

此外我们可以使用大括号 {} 来转义大括号，如下实例：

print ("{} 对应的位置是 {{0}}".format("runoob"))
runoob 对应的位置是 {0}
1
2

input输入

会让程序停止, 等待输入

input("请输入数据")
1

可以填一个输入的提示语, 返回值是输入的数据的字符串

数据转换

int

把一个字符串转换为整数, 这一个里面必须都是数字

tuple, set, liset

列表, 元组, 集合的相互转换, 这几个转换的时候不是改变之前的数据, 是返回一个新的数据

可以使用set进行快速去重

random

随机数

import random
random.randint(start, stop)
1
2

start – 必需， 一个整数，指定开始值（包含在范围内），即生成的随机整数可以取到这个值。

stop – 必需， 一个整数，指定结束值（包含在范围内），即生成的随机整数可以取到这个值。

数组乱序

import random
nums  = [1, 2, 3, 4, 5, 6]
randoms.shuffle(nums) # 洗牌
randoms.choice(nums) # 随机获取一个
1
2
3
4

迭代

range

range(start, stop[, step])
1

start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;

stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5

step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

>>>x = 'runoob'
>>> for i in range(len(x)) :
...     print(x[i])
... 
r
u
n
o
o
b
1
2
3
4
5
6
7
8
9
10

在python里面这一个函数返回一个数组, python3里面返回的是一个可迭代的对象

In [2]: print(type(range(1, 10)))
<class 'range'>
1
2

可迭代对象处理

map映射处理

使用提供的函数对一个序列进行映射

map(function, iterable, *iterables)
1

返回一个将 function 应用于 iterable 的每一项，并产生其结果的迭代器。 如果传入了额外的 iterables 参数，则 function 必须接受相同个数的参数并被用于到从所有可迭代对象中并行获取的项。

a = map(lambda x: x*x, [1, 2, 3])
print(a)

for temp in a:
    print(temp)
1
2
3
4
5

PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
<map object at 0x000001EFB54D76D0>
1
4
9
1
2
3
4
5

a  = map(lambda x, y: x+y , [1, 2, 3], [4, 5, 6])
for temp in a:
    print(temp)
1
2
3

PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
5
7
9
1
2
3
4

def f1(x, y):
    return {x:y}

l1 = [0, 1, 2, 3, 4, 5, 6]
l2 = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']

a = map(f1, l1, l2)
print(list(a))
1
2
3
4
5
6
7
8

PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
[{0: 'Sun'}, {1: 'Mon'}, {2: 'Tue'}, {3: 'Wed'}, {4: 'Thu'}, {5: 'Fri'}, {6: 'Sat'}]
1
2

filter过滤

filter(function, iterable)
1

使用 iterable 中 function 返回真值的元素构造一个迭代器。 iterable 可以是一个序列，一个支持迭代的容器或者一个迭代器。 如果 function 为 None，则会使用标识号函数，也就是说，iterable 中所有具有假值的元素都将被移除。

reduce遍历处理

python3 中，函数被移到了functools模块中

functools.reduce(function, iterable[, initializer])
1

将两个参数的 function 从左至右积累地应用到 iterable 的条目，以便将该可迭代对象缩减为单一的值。 例如，reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 是计算 ((((1+2)+3)+4)+5) 的值。 左边的参数 x 是积累值而右边的参数 y 则是来自 iterable 的更新值。 如果存在可选项 initializer，它会被放在参与计算的可迭代对象的条目之前(初始值)，并在可迭代对象为空时作为默认值。 如果没有给出 initializer 并且 iterable 仅包含一个条目，则将返回第一项。

from functools import reduce
a = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5])
print(a)
1
2
3

PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
15
1
2

每一次的返回值会给x, 遍历获取下一个数值给y

from functools import reduce
a = reduce(lambda x, y: x + y, [1, 2, 3, 4, 5], 5)
print(a)
1
2
3

5+1+2+3+4+5 = 20

字符串操作

获取字符串特征

str1 = 'hello, world!'
# 通过内置函数len计算字符串的长度
print(len(str1)) # 13

# 检查字符串是否以指定的字符串开头
print(str1.startswith('He')) # False
print(str1.startswith('hel')) # True

# 检查字符串是否以指定的字符串结尾
print(str1.endswith('!')) # True

str2 = 'abc123456'

# 检查字符串是否由数字构成
print(str2.isdigit())  # False

# 检查字符串是否以字母构成
print(str2.isalpha())  # False

# 检查字符串是否以数字和字母构成
print(str2.isalnum())  # True
str3 = '  jackfrued@126.com '
print(str3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

格式化操作

# 获得字符串首字母大写的拷贝
print(str1.capitalize()) # Hello, world!

# 获得字符串每个单词首字母大写的拷贝
print(str1.title()) # Hello, World!

# 获得字符串变大写后的拷贝
print(str1.upper()) # HELLO, WORLD!

# 将字符串以指定的宽度居中并在两侧填充指定的字符
print(str1.center(50, '*'))

# 将字符串以指定的宽度靠右放置左侧填充指定的字符
print(str1.rjust(50, ' '))

# 获得字符串修剪左右两侧空格之后的拷贝
print(str3.strip())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

查找

# 与find类似但找不到子串时会引发异常
# print(str1.index('or'))
# print(str1.index('shit'))

# 从字符串中查找子串所在位置
print(str1.find('or')) # 8
print(str1.find('shit')) # -1

# 从右侧开始找, 可以使用这一个获取后缀名
print(str1,rfind("0")) 

# 查看里面有没有
print(if 'a' in str1)
1
2
3
4
5
6
7
8
9
10
11
12
13

替换

# 替换字符串里面的字符, 返回新的, 原来的不改变
# str.replace(old, new[, max]), 可选参数, 替换的次数
test_srt = "Hello, World!"
print(test_srt.replace("World", "Python"))
print(test_srt)
'''
Hello, Python!
Hello, World!
'''
1
2
3
4
5
6
7
8
9

切片

str.split(str="", num=string.count(str)).
1

str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。

num – 分割次数。默认为 -1, 即分隔所有。

这一个函数的返回值是一个字符串的数组

str.partition(str)
1

partition() 方法用来根据指定的分隔符将字符串进行分割，返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。

str.splitlines(str)
1

splitlines()是Python字符串对象的一个方法，用于按照字符串中的换行符将字符串拆分为多行。它会返回一个包含拆分后每行内容的列表。

拼接

str.join(sequence)
symbol = "-";
seq = ("a", "b", "c"); # 字符串序列
print symbol.join( seq );
# a-b-c
1
2
3
4
5

join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。join里放列表、字符串、字典也是可以的

列表操作

添加

# 在后面插入, 追加(只添加一个元素)
list.append(new)
# 拼接链表, 把新的链表拼接在前面
list2.extend(list1)
# 随机插入, 需要指定位置, 超出长度的时候相当于追加
list3.insert(index, object)
1
2
3
4
5
6

删除

# 根据一个下标对元素进行删除
del list[n] 
# pop删除最后一个元素
list.pop()
# 根据一个值进行删除
list.remove(value)
1
2
3
4
5
6

修改

list[pos] = new_value
1

查

# 查看里面有没有这一个数据
value in list
value not in list
# 查看某一个数据的个数
list.count("value")
1
2
3
4
5

排序

# 排序, 默认为从小到大
list.sort()
# 从大到小
list.sort(reverse=True)
# 倒序
list.reverse()
1
2
3
4
5
6

字典

查找

dict[key]如果这一个key不存在的话, 会导致报错

# 安全的方法
dict.get(key)
1
2

使用这一个方法, 不存在的时候会返回一个NULL, 可以传入第二个参数, 会使用这一个参数作为没有时候的返回值

添加数据

dict.[newkey] = value
1

如果这一个值不存在的话, 这一个键值对会进行增加

删除

# 删除其中一个键值对
del dict.[key]
# 清空一个字典
dict.clear()
# 删除这一个字典
del dict
1
2
3
4
5
6

排序

使用sort的时候, 不能对一个字典里列表面的数据进行排序, 这时候可以设置sort函数的key参数

这一个key指向一个函数, 这一个函数会返回一个用于比较的值

stus = [
    {"name": "jiao", "age":21}, {"name": "shi", "age":23}, {"name": "dong", "age":19}, 
]

# def sort_by_age(arg):
#    return arg["age"]

# print(stus)
# stus.sort(key = sort_by_age)
print(stus)
stus.sort(key = lambda arg: arg["age"])
1
2
3
4
5
6
7
8
9
10
11

PS E:\JHY\python\2024-4-22> python -u "e:\JHY\python\2024-4-22\main.py"
[{'name': 'jiao', 'age': 21}, {'name': 'shi', 'age': 23}, {'name': 'dong', 'age': 19}]
[{'name': 'dong', 'age': 19}, {'name': 'jiao', 'age': 21}, {'name': 'shi', 'age': 23}]
1
2
3

其他函数

可以直接调用的函数

len, max, min, del

获取长度, 最大值, 最小值, 删除一个元素

isinstance比较类型

python中isinstance()函数详解_python instance函数-CSDN博客

判断一个对象是否是一个已知的类型

isinstance(object, classinfo)

isinstance(2,int)
isinstance(12,(str,int,list)) 
1
2
3
4

classinfo – 可以是直接或间接类名、基本类型或者由它们组成的元组。

isinstance()函数和type()函数很类似。但是两者又有区别，type() 不会认为子类是一种父类类型，不考虑继承关系。isinstance() 会认为子类是一种父类类型，考虑继承关系。

class A:
    pass
 
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False
1
2
3
4
5
6
7
8
9
10

hasattr查看参数

hasattr(object, name)
1

查看一个对象里面有没有一个属性