Python基础总结_str=鈥渞unoob鈥漰rint(str.strip())-CSDN博客

本文链接：https://blog.csdn.net/qq_63974399/article/details/125643989

语法

注释：多行注释可以用多个 # 号，还有 ’ ’ ’ 或 " " "表示
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 \ 来实现多行语句
print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=" "：

基本数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。
Python允许同时为多个变量赋值：

a = b = c = 1#创建一个整型对象，值为 1，从后向前赋值，三个变量被赋予相同的数值。
a, b, c = 1, 2, "runoob"#两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。

Python3 中有六个标准的数据类型：

Number（数字）
String（字符串）
List（列表）
Tuple（元组）
Set（集合）
Dictionary（字典）
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

一、Number（数字）

Python3 支持 int、float、bool、complex（复数）。
在Python 3里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。

内置的 type() 函数可以用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

此外还可以用 isinstance 来判断：

>>> a = 111
>>> isinstance(a, int)
True

Python3 中，bool 是 int 的子类，True 和 False 可以和数字相加，True== 1、False== 0 会返回 True。
指定一个值时，Number 对象就会被创建，使用del语句删除单个或多个对象：

var1 = 1
del var

数值的除法包含两个运算符：/ 返回一个浮点数，// 返回一个整数。

>>> 2 / 4  # 除法，得到一个浮点数
0.5
>>> 2 // 4 # 除法，得到一个整数
0
>>> 17 % 3 # 取余
2

二、String（字符串）

Python中的字符串用单引号 ’ 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符。

字符串的截取的语法格式如下：
变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置。
加号 + 是字符串的连接符，星号 * 表示复制当前字符串，与之结合的数字为复制的次数。

str = 'Runoob'

print (str)          # 输出字符串
print (str[0:-1])    # 输出第一个到倒数第二个的所有字符
print (str[0])       # 输出字符串第一个字符
print (str[2:5])     # 输出从第三个开始到第五个的字符
print (str[2:])      # 输出从第三个开始的后的所有字符
print (str * 2)      # 输出字符串两次，也可以写成 print (2 * str)
print (str + "TEST") # 连接字符串

Python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob

与 C 字符串不同的是，Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = ‘m’ 会导致错误。Python 没有单独的字符类型，一个字符就是长度为1的字符串。
格式化字符串的函数 str.format()，它增强了字符串格式化的功能。基本语法是通过 {} 和 : 来代替以前的 % :

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'
print("网站名：{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
>>> print("{:.2f}".format(3.1415926))
3.14

f-string 为字面量格式化字符串，f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去：

>>> name = 'Runoob'
>>> f'Hello {name}'  # 替换变量
'Hello Runoob'
>>> f'{1+2}'         # 使用表达式
'3'

>>> w = {'name': 'Runoob', 'url': 'www.runoob.com'}
>>> f'{w["name"]}: {w["url"]}'
'Runoob: www.runoob.com'

python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符:

para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
'''
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB (    )。
也可以使用换行符 [ 
 ]。
 '''

三、List（列表）

List（列表）是 Python 中使用最频繁的数据类型。列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

与Python字符串不一样的是，列表中的元素是可以改变的：

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = []   # 将对应的元素值设置为 []
>>> a
[9, 2, 6]

列表截取的语法格式如下：
变量[头下标:尾下标]
索引值以 0 为开始值，-1 为从末尾的开始位置。Python 列表截取可以接收第三个参数，参数作用是截取的步长，如果第三个参数为负数表示逆向读取。以下实例用于翻转字符串：

    # inputWords[-1::-1] 有三个参数
    # 第一个参数 -1 表示最后一个元素
    # 第二个参数为空，表示移动到列表末尾
    # 第三个参数为步长，-1 表示逆向
    inputWords=inputWords[-1::-1]

更新列表：使用 append() 方法来添加列表项：

list1 = ['Google', 'Runoob', 'Taobao']
list1.append('Baidu')
print ("更新后的列表 : ", list1)
#更新后的列表 :  ['Google', 'Runoob', 'Taobao', 'Baidu']

删除列表元素：可以使用 del 语句来删除列表的的元素：

list = ['Google', 'Runoob', 1997, 2000]
 
print ("原始列表 : ", list)
del list[2]
print ("删除第三个元素 : ", list)
#原始列表 :  ['Google', 'Runoob', 1997, 2000]
#删除第三个元素 :  ['Google', 'Runoob', 2000]

基本操作：

四、Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取。其实，可以把字符串看作一种特殊的元组。

构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = ()    # 空元组
 # 一个元素，需要在元素后添加逗号，否则括号会被当作运算符使用：
>>> tup1 = (50)
>>> type(tup1)     # 不加逗号，类型为整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1)     # 加上逗号，类型为元组
<class 'tuple'>

string、list 和 tuple 都属于 sequence（序列）。

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

tup1 = (12, 34.56)
tup2 = ('abc', 'xyz')
 
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
 
# 创建一个新的元组
tup3 = tup1 + tup2
print (tup3)
#(12, 34.56, 'abc', 'xyz')

删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组：

tup = ('Google', 'Runoob', 1997, 2000)
 
print (tup)
del tup
print ("删除后的元组 tup : ")
print (tup)

元组被删除后，输出变量会发生异常。

五、Set（集合）

集合（set）是一个无序的不重复元素序列。由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 这里演示的是去重功能
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 快速判断元素是否在集合内
True
>>> 'crabgrass' in basket
False

>>> # 下面展示两个集合间的运算.
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素
{'r', 'd', 'b', 'm', 'z', 'l'}

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

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.add("Facebook")
>>> print(thisset)
{'Taobao', 'Facebook', 'Google', 'Runoob'}

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

>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> print(thisset)
{1, 3, 'Google', 'Taobao', 'Runoob'}
>>> thisset.update([1,4],[5,6])  
>>> print(thisset)
{1, 3, 4, 5, 6, 'Google', 'Taobao', 'Runoob'}

随机删除集合中的一个元素，语法格式如下：
s.pop()

thisset = set(("Google", "Runoob", "Taobao", "Facebook"))
x = thisset.pop()

print(x)

多次执行测试结果都不一样,因为是随机的。
set 集合的 pop 方法会对集合进行无序的排列，然后将这个无序排列集合的左面第一个元素进行删除。

六、Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型，它是可变容器模型，且可存储任意类型对象。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 { } 标识，它是一个无序的键(key) : 值(value) 的集合。

d = {key1 : value1, key2 : value2, key3 : value3 }

键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的，如字符串，数字。

创建字典：

tinydict1 = { 'abc': 456 }
tinydict2 = { 'abc': 123, 98.6: 37 }
#使用内建函数 dict() 创建字典：
emptyDict = dict()
# 打印字典
print(emptyDict)
 
# 查看字典的数量
print("Length:",len(emptyDict))
 
# 查看类型
print(type(emptyDict))

'''
{}
Length: 0
<class 'dict'>
'''

修改字典:

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
 
tinydict['Age'] = 8               # 更新 Age
tinydict['School'] = "菜鸟教程"  # 添加信息
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])
#tinydict['Age']:  8
#tinydict['School']:  菜鸟教程

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

tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del tinydict['Name'] # 删除键 'Name'
tinydict.clear()     # 清空字典
del tinydict         # 删除字典
#会引发异常，因为用执行 del 操作后字典不再存在
print ("tinydict['Age']: ", tinydict['Age'])
print ("tinydict['School']: ", tinydict['School'])

数据类型转换

隐式类型转换
对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。

num_int = 123
num_flo = 1.23

num_new = num_int + num_flo#float

整型和字符串类型运算结果会报错，输出 TypeError。 Python 在这种情况下无法使用隐式转换。但是，Python 为这些类型的情况提供了一种解决方案，称为显式转换。
显式类型转换

a = int("3") # z 输出结果为 3
b = float("4.2") # w 输出结果为 4.2
x = str("s1") # x 输出结果为 's1'
y = str(2)    # y 输出结果为 '2'
z = str(3.0)  # z 输出结果为 '3.0'

Python 推导式

Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。
Python 支持各种数据结构的推导式：

列表推导式

计算 30 以内可以被 3 整除的整数并加1：

>>> multiples = [i+1 for i in range(30) if i % 3 == 0]
>>> print(multiples)
[1, 4, 7, 10, 13, 16, 19, 22, 25, 28]

字典推导式

提供三个数字，以三个数字为键，三个数字的平方为值来创建字典

>>> dic = {x: x**2 for x in (2, 4, 6)}
>>> dic
{2: 4, 4: 16, 6: 36}
>>> type(dic)
<class 'dict'>

集合推导式

判断不是 abc 的字母并输出：

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'d', 'r'}
>>> type(a)
<class 'set'>

元组推导式（生成器表达式）

元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []，另外元组推导式返回的结果是一个生成器对象。
例如，可以使用下面的代码生成一个包含数字 1~9 的元组：

>>> a = (x for x in range(1,10))
>>> a
<generator object <genexpr> at 0x7faf6ee20a50>  # 返回的是生成器对象

>>> tuple(a)       # 使用 tuple() 函数，可以直接将生成器对象转换成元组
(1, 2, 3, 4, 5, 6, 7, 8, 9)