python基础知识点

最新推荐文章于 2024-08-10 23:14:03 发布

@过往@

最新推荐文章于 2024-08-10 23:14:03 发布

阅读量252

点赞数

分类专栏： python 文章标签： python 开发语言

本文链接：https://blog.csdn.net/m0_59535683/article/details/127936543

版权

python 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

字符串（string）

1、字符串的定义

我们可以使用“”或者‘’来创建字符串。
```
var1 = 'Hello World!'
var2 = "Runoob"
```
字符串是不可变类型，我们对于字符串的增删改查都是利用的重新赋值
Python 不支持单字符类型，单字符在 Python 中也是作为一个字符串使用

2、访问字符串中的值

Python 访问子字符串，可以使用方括号 [] 来截取字符串

var1 = 'Hello World!'
var2 = "Runoob"
print(var1[0])
print(var1[1])
# 运行结果
# H
# e

字符串的索引是从0为开始值，-1是从末尾开始的位置

3、字符串的切片

字符串的切片是根据索引进行的，切片的原则是中括号内的索引包前不包后。

字符串的切片长度不能超过字符串本身的长度

var1 = 'Hello World!'
print(var1[0:3])
print(var1[3:])
print(var1[:3])
print(var1[::-1])
print(var1[-3::-1])
# 运行结果
# Hel
# lo World!
# Hel
# !dlroW olleH
# lroW olleH

4、字符串转义字符

符号	名称	作用
\	续行符	将一行内容写道多行
\\	反斜杠符号	通过\转义\\表示单斜杠
\a	响铃	执行后电脑又响声
\b	退格
\0000	空
\n	换行符
\v	纵向制表符
\t	横向制表符
\r	回车	将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。

5、字符串运算

+：字符串串接
*：重复输出字符串
[]：通过索引获取字符串中的字符
[:]：截取字符串中的一部分，遵循左闭右开原则，str[0:2] 是不包含第 3 个字符的
in：成员运算符
not in：成员运算符
r/R：原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
%：格式字符串

6、字符串格式化输出

基本用法：是将一个值插入到一个有字符串格式符 %s 的字符串中
f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去

7、字符串的内建函数

capitalize():将字符串的第一个字符转化为大写

var = 'hello world!'
print(var.capitalize())
# 运行结果
# Hello world!

center(width,fillchar)：返回一个指定的宽度width居中的字符串，fillchar为填充的字符默认为空格

var = 'hello world!'
print(var.center(40, "#"))
print(var.center(40))
# 运行结果
# ##############hello world!##############
#               hello world!

conut(str,beg=0,end=len(string)):返回str在string里面出现的次数，如果beg或者end指定返回指定范围内str出现的次数
```
var = 'hello world!'
print(var.count("l"))
print(var.count("h"))
# 运行结果
# 3
# 1
```
endwith(suffix,beg=o,end=len(string)):检查字符串是否以suffix结束，如果beg或者end指定检查指定的范围内是否以suffix结束，如果是返回True，否则返回False。
```
var = 'hello world!'
print(var.endswith("!"))
print(var.endswith("d"))
# 运行结果
# True
# False
```
find(str,bef=0,end=len(string))：检测str是否包含在字符串中，如果指定范围beg和end，则检查是否包含在指定范围内，如果包含返回开始的索引值，则返回-1
```
var = 'hello world!'
print(var.find("h"))
print(var.find("!"))
# 运行结果 （找到的结果是该字符串中的第一个字符，且返回值是该字符的下标）
# 0
# 11
```

index(str,beg=0,end=len(string)):和find方法一样，只不过如果str不在字符串中会报异常。

var = 'hello world!'
print(var.index("h"))
print(var.index("!"))
# 运行结果 （找到的结果是该字符串中的第一个字符，且返回值是该字符的下标）没找到会报错
# 0
# 11

isalnum():如果字符串至少有一个字符，且这些字符是数字或者字母，则返回True，否则返回False
isalpha():判断字符串是不是都是字母。
isdight():判断字符串是不是都是数字。
islower()：判断字符串是不是都是小写。
isspace():判断字符串是不是都是空白
istitle()：判断字符串是不是标题化的（即：单词以大写字母开头）。
isupper():判断字符串是不是都是大写字符
join(seq):以指定字符串作为分隔符，将seq中的所有元素合为一个新的字符串
```
var = '-'
se = ("h","l")
print(var.join(se))
# 运行结果
# h-l
```

len(string)：返回字符串长度

var = 'hello world!'
print(len(var))
# 运行结果
# 12

ljust(width,fillchar)：返回一个源字符串左对齐，并使用fillchar填充长度至width的新的字符串
```
var = 'hello world!'
print(var.ljust(40,"#"))
# 运行结果
# hello world!############################
```

lower():转换字符串中所有大写字符为小写

var = 'hello world!'
var2 = var.upper()
print(var2.lower())
# 运行结果
# hello world!

lstrip():去掉字符串左边的空格。

var = '        hello world!'
print(var.lstrip())
# 运行结果
# hello world!

max(str):返回字符串中的最大的字母

var = 'hello world!'

print(max(var))
# 运行结果
# w

min(str)：返回字符串中最小的字母

var = 'hello world!'

print(min(var))
# 运行结果
#

replace(ole,new,[max]):替换字符

var = 'hello world!'
print(var.replace("l","-"))
# 运行结果
# he--o wor-d!

rfind()；从右侧寻找该字符
rindex():与rfind用法类似，找不到会报错
rjust()；返回字符串右对齐，并且可以指定字符串长度，不足的用空格或者指定字符补充。
```
var = 'hello world!'
print(var.rjust(40,"#"))
# 运行结果
# ############################hello world!
```

rstrip():删除字符串右侧的空格或者指定字符

var = 'hello world!#####################'
print(var.rstrip("#"))
# 运行结果
# hello world!

split(str=“”,num=string.count(str)):以str为分隔符截取字符串，如果num有指定值，则仅截取num+1个字符串，截取的字符串分装在列表中
```
var = 'hello world!'
print(var.split("l"))
# 运行结果
# ['he', '', 'o wor', 'd!']
```

startwith():检查字符串是否以指定字符开头。

var = 'hello world!'
print(var.startswith("h"))
# 运行结果
# True

strip():取出字符串两端的空格，或者指定字符

var = '                hello world!                '
print(var.strip())
# 运行结果
# hello world!

swapcase()：将字符串中的大小写颠倒

var = 'Hello World!'
print(var.swapcase())
# 运行结果
# hELLO wORLD!

title():将所有单词都转化为大写字母开头

var = 'hello orld!'
print(var.title())
# 运行结果
# Hello Orld!

upper():将字符串中的字母转化为大写

var = 'hello orld!'
print(var.upper())
# 运行结果
# HELLO ORLD!

列表（list）

1、列表的定义

列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可
列表的索引与切片的用法与字符串一致
列表可以嵌套列表

2、列表的函数

len（list）：列表元素个数
max（list）：返回列表元素最大值
min（list）：返回列表元素最小值
list(seq):将元组转化为列表

3、列表的方法

list.append():在列表末尾添加新的对象
list.count（）:统计列表中某个元素的个数
list.extend():在列表末尾一次性追加另一个序列中的多个值
list.index():从列表中找出某个值第一个匹配项的索引位置
list.insert(index,obj):将对象插入列表
list.pop():移除列表中的一个元素，并且返回该元素的值（使用索引移除）
list.remove():移除列表中某个值的第一个匹配项
list.reverse():反向列表中的元素
list.sort():对原列表进行排序
list.clear():清空列表
list.copy():浅复制列表

元组（tuple）

1.元组的定义

元组与列表类似，但元组中的元素不可修改。
元组必须使用小括号，元组中的元素用逗号隔开，且只有一个元素时，必须在该元素后面加上逗号。
元组创建方法：

# 元组的创建
# 空元组的创建
tup1 = ()
tup2 = tuple()
# 定义非空元组
tup3 = (1,2,3,3)
tup4 = (1,)
tup5 = tuple(1,2,3)
tup6 = tuple(1,)

2、元组的访问

元组可以使用下表索引来访问，使用方法与列表和字符串类似，但元组内容不可以修改

tup = ("hello","1",1,3000,"nihao")
print(tup[1]) # 输出的值便为：字符串类型的1
print(tup[2]) # 输出的值便为：整型的1

切片:元组的切片与字符串和列表一样，切片以后的元素构成一个新的元组

tup = ("hello","1",1,3000,"nihao")
print(tup[1:2]) # 输出结果为：("1",1)
print(rup[::-1]) # 将元组的内容倒叙输出

3、修改元组

元组中的元素不可以修改，但我们可以对元组中的元素进行连接组合

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
tup = tup1+tup2 
print(tup) # 输出一个新的元组(12, 34.56,'abc', 'xyz')
# 也可以利用切片对元组进行修改
tup = ("hello","1",1,3000,"nihao")
print(tup[1:2]) # 输出结果为：("1",1)

4、删除元组

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
```
tup = (1,"we",3)
del tup # 使用系统内置函数删除元组
```

5、元组运算符

可以使用 len函数统计元组中元素的个数
可以使用+将多个元组进行拼接
可以使用*将元组进行复制
可以使用in判断元素是否在元组中
可以使用for循环迭代输出元组中的元素

6、元组的内置函数

len(tuple)

计算元组中元素的个数
max(tuple)

返回元组中元素最大值。
min()

返回元组中元素最小值。
tuple()

可以将列表转换为元组
tuple.index()

可以在元组中寻找元素，只返回寻找到的第一个，没有找到则会报错
tuple.count()

返回需要找的元素在元组中的个数，没有找到返回值为0

7、总结

元组是不可修改的
元组是可以迭代的
元组是有序序列
元组内可以嵌套元组

字典（dict)

1、字典定义

字典是一种可变容器模型，且可以存储任意类型的对象
字典的每个键值 key:value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中 ,格式如下所示：
键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组

2、修改字典

向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对如下实例:

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
 # 更新和添加都是通过字典的键去完成的
tinydict['Age'] = 8 # 更新
tinydict['School'] = "RUNOOB" # 添加

3、删除字典

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

del tinydict['Name']  # 删除键是'Name'的条目
tinydict.clear()      # 清空字典所有条目
del tinydict          # 删除字典

注意使用del删除字典之后该字典就不存在了

4、字典的特性

字典值可以是没有限制。
字典的键需要注意两点：
- 不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住
- 键必须不可变，所以可以用数字，字符串或元组充当，所以用列表就不行

5、字典的内置函数

len(dict):计算字典元素个数，即键的总数
str(dict):输出字典可打印的字符串表示

6、字典的内置方法

dict.clear():删除字典内所有元素

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
tinydict.clear() # 是一个过程
print(tinydict)
# 运行结果： {}

dict.copy():返回一个字典的浅复制

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict1 = tinydict.copy() # 将复制的值重新给一个字典
print(dict1)

dict.fromkeys(seq[,val]):创建一个新字典，以序列 seq 中元素做字典的键，val 为字典所有键对应的初始值
```
list1 = ["a", "b", "c", "d"]
dict1 = dict.fromkeys(list1, 10)
print(dict1)
```

dict.get(key,defaylt=None):返回指定键的值，如果值不在字典中返回default值

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
value = tinydict.get("Name")
value1 = tinydict.get("name")
print("value的值是：",value)
print("value1的值是：",value1)
# 运行结果：
# value的值是： Zara
#  value1的值是： None

dict.items():以列表返回可遍历的(键, 值) 元组数组

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
list1 = tinydict.items()
print(list1)
# 运行结果：
# dict_items([('Name', 'Zara'), ('Age', 7), ('Class', 'First')])

dict.keys():以列表返回一个字典所有的键

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
list1 = tinydict.keys()
print(list1)
# 运行结果：
# dict_keys(['Name', 'Age', 'Class'])

dict.setdefault(key,default=None):和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
tinydict.setdefault("Name")
dicct1 = tinydict.setdefault("Name")
print("dicct1是：",dicct1)
print(tinydict)
tinydict.setdefault("xuehao","123456")
dict2 = tinydict.setdefault("xuehao","123456")
print("dict2是：",dict2)
print(tinydict)
# 运行结果是：
# dicct1是： Zara
# {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
# dict2是： 123456
# {'Name': 'Zara', 'Age': 7, 'Class': 'First', 'xuehao': '123456'}

dict.update(dict2):把字典dict2的键/值对更新到dict里

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict2 = {"1":12,"2":22}
tinydict.update(dict2)
print(tinydict)
tinydict.update({"ni":12})
print(tinydict)
# 运行结果
# {'Name': 'Zara', 'Age': 7, 'Class': 'First', '1': 12, '2': 22}
# {'Name': 'Zara', 'Age': 7, 'Class': 'First', '1': 12, '2': 22, 'ni': 12}

dict.values():以列表返回字典中的所有值

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
list1 = tinydict.values()
print(list1)
# 运行结果
# dict_values(['Zara', 7, 'First'])

dict.pop(key,default):删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
tinydict.pop("Name")
print(tinydict)
ss = tinydict.pop("Class")
print(ss)
print(tinydict)
# 运行结果
# {'Age': 7, 'Class': 'First'}
# First
# {'Age': 7}

dict.popitem():返回并删除字典中的最后一对键和值。

tinydict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
tinydict.popitem()
print(tinydict)
ss = tinydict.popitem()
print(ss)
print(tinydict)
# 运行结果
# {'Name': 'Zara', 'Age': 7}
# ('Age', 7)
# {'Name': 'Zara'}

集合（set）

1、集合定义

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

2、集合添加元素

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

thisset = set(("Google", "Runoob", "Taobao"))
thisset.add("Facebook")
print(thisset)
# 运行结果
# {'Taobao', 'Facebook', 'Google', 'Runoob'}

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

thisset = set(("Google", "Runoob", "Taobao"))
thisset.update({1,3})
print(thisset)
thisset.update([1,4],[5,6])  
print(thisset)
# 运行结果
# {1, 3, 'Google', 'Taobao', 'Runoob'}
# {1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}

3、移除元素

s.remove(x) 将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误

thisset = set(("Google", "Runoob", "Taobao"))
thisset.remove("Taobao")
print(thisset)
thisset.remove("Facebook")   # 不存在会发生错误
# 运行结果
# {'Google', 'Runoob'}

s.discard(x)此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

thisset = set(("Google", "Runoob", "Taobao"))
thisset.discard("Facebook")  # 不存在不会发生错误
print(thisset)
# 运行结果
# {'Taobao', 'Google', 'Runoob'}

s.pop() 我们也可以设置随机删除集合中的一个元素，语法格式如下：

注意：set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除
```
thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()
print(x)
print(thisset)
# 运行结果
# Runoob
# {"Google",  "Taobao", "Facebook"}
```

4、计算集合元素个数

len(s): 计算集合s元素个数

thisset = set(("Google", "Runoob", "Taobao"))
len(thisset)
# 运行结果：3

5、清空集合

s.clear():用于清空集合内部的元素

thisset = set(("Google", "Runoob", "Taobao"))
thisset.clear()
print(thisset)
# 运行结果：set()

6、判断元素是否存在集合中存在

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> "Runoob" in thisset
True
>>> "Facebook" in thisset
False

7、集合内置方法

set.add():为集合添加元素

thisset = {"Google", "Runoob", "Taobao", "Facebook"}
thisset.add("book")
print(thisset)
# 运行结果
# {'Facebook', 'Google', 'book', 'Runoob', 'Taobao'}

set.clear():移除集合中的所有元素

thisset = {"Google", "Runoob", "Taobao", "Facebook"}
thisset.clear()
print(thisset)
# 运行结果
# set()

set.copy(): 拷贝一个集合

thisset = {"Google", "Runoob", "Taobao", "Facebook"}
this2 = thisset.copy()
print(this2)
# 运行结果
# {'Google', 'Facebook', 'Taobao', 'Runoob'}

set.difference():返回多个集合的差集

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}
z = x.difference(y)
print(z)
# 运行结果
# {'banana', 'cherry'}

set.difference_update():移除集合中的元素，该元素在指定的集合也存在。

x = {"apple", "banana", "cherry"}
y = {"google", "microsoft", "apple"}

x.difference_update(y)

print(x)
# 运行结果
# {'banana', 'cherry'}

set.dicard(): 删除集合中指定的元素

fruits = {"apple", "banana", "cherry"}
 
fruits.discard("banana") 
 
print(fruits)
# 运行结果
# {'apple', 'cherry'}

set.intersection(): 返回集合的交集

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
z = x.intersection(y) 
 
print(z)
# 运行结果
# {'apple'}

set.intersection_update(): 返回集合的交集。

x = {"apple", "banana", "cherry"}  # y 集合不包含 banana 和 cherry，被移除 
y = {"google", "runoob", "apple"}
 
x.intersection_update(y) 
 
print(x)
# 运行结果
# {'apple'}

set.isdisjoint(): 判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "facebook"}
 
z = x.isdisjoint(y) 
 
print(z)
# 运行结果
# True

set.issubset(): 判断指定集合是否为该方法参数集合的子集。

x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"}
 
z = x.issubset(y) 
 
print(z)
# 运行结果
# True

set.isuperset(): 判断该方法的参数集合是否为指定集合的子集

x = {"f", "e", "d", "c", "b", "a"}
y = {"a", "b", "c"}
 
z = x.issuperset(y) 
 
print(z)
# 运行结果
# True

set.pop(): 随机移除元素

fruits = {"apple", "banana", "cherry"}
 
x = fruits.pop() 
 
print(x)
# 运行结果
# apple

set.remove(): 移除指定元素

fruits = {"apple", "banana", "cherry"}
 
fruits.remove("banana") 
 
print(fruits)
# 运行结果
# {'cherry', 'apple'}

set.symmetric_difference(): 返回两个集合中不重复的元素集合。

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
z = x.symmetric_difference(y) 
 
print(z)
# 运行结果
# {'banana', 'google', 'runoob', 'cherry'}

set.symmetric_difference_update():移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
x.symmetric_difference_update(y) 
 
print(x)
# 运行结果
# {'google', 'runoob', 'cherry', 'banana'}

set.union(): 返回两个集合的并集

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
z = x.union(y) 
 
print(z)
# 运行结果
# {'google', 'cherry', 'apple', 'runoob', 'banana'}

set.update(): 给集合添加元素

x = {"apple", "banana", "cherry"}
y = {"google", "runoob", "apple"}
 
x.update(y) 
 
print(x)
# 运行结果
# {'cherry', 'runoob', 'google', 'apple', 'banana'}