[Python]一、Python基础编程（1）_python基础编程(1)csdn-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_44428807/article/details/142305101

F:\BaiduNetdiskDownload\2023人工智能开发学习路线图\1、人工智能开发入门\1、零基础Python编程

1. Python简介

Python优点：

学习成本低

开源

适应人群广泛

应用领域广泛

1.1 Python解释器

下载地址：Download Python | Python.org

1.2 Python开发IDE -- Pycharm

2. 基础语法

2.1 注释

注释的作用：用自然语言对代码进行解释说明，方便后期维护。
注释的分类
- 单行注释： # 注释内容
- 多行注释："""注释内容""" 或 '''注释内容'''
解释器不执行注释的内容

2.2 变量

定义：程序中数据都是临时存储在内存中，为了更快速的查找和使用这个数据，通常把这个数据在内存中存储之后定义一个名称，这个名称就是变量。

标识符：
- 由数字、字母、下划线组成；
- 不能数字开头
- 不能使用内置关键字

False None True and as assert break class

continue def del elif else except finally for

from global if import in is lambda nonlocal

not or pass raise return try while with

yield

- 严格区分大小写

2.3 数据类型

`type()` 函数用于返回对象的类型。它可以接受一个参数，也可以接受三个参数。

1. 当只传递一个参数时，它返回该参数的类型。
x = 5
print(type(x)) # 输出：<class 'int'>

2. 当传递三个参数时，`type()` 可以返回一个新的类型对象。语法如下：
type(name, bases, dict)

- `name`: 类型的名称。
- `bases`: 元组，表示基类的类型。
- `dict`: 字典，包含类型的属性。

这种用法通常用于动态创建类：
MyCustomClass = type('MyCustomClass', (object,), {'attr': 'value'})
obj = MyCustomClass()

print(obj.attr) # 输出value
print(type(obj)) # 输出：<class '__main__.MyCustomClass'>

总之，`type()` 函数在Python中用于返回对象的类型，也可以用于动态创建新的类型。

动态创建类在编程中有几种常见用途，其中包括：

工厂模式（Factory Pattern）：动态创建类允许根据运行时的条件创建不同类型的对象，从而实现工厂模式，根据需要创建不同种类的类实例。

运行时代码生成（Metaprogramming）：有时候需要在运行时生成某些类以及这些类的属性和方法，这种动态创建类的机制可以用于元编程等需要在运行时构建代码的场景。

插件系统（Plugin System）：通过动态创建类，可以实现插件系统，动态加载和实例化插件类以扩展应用程序的功能。

ORM（对象关系映射）：在ORM库中，动态创建类可以用于根据数据库模式创建对应的对象类。

2.4 输出

2.4.1 格式化占位符号

%s:字符串，也可以承接int，float等类型

%d：有符号十进制整数

%f：浮点数

%c：字符

%u：无符号十进制整数

%e：小写e的科学计数法

%E：大写E的科学计数法

%g：%f和%e的简写

%G：%f和%E的简写

%06d ：表示输出的整数显示位数，不⾜以 0 补全，超出当前位数则原样输出，

print('--%06d--' % 123) # --000123--

print('--%-6d--' % 123) # --123 --

%.2f ：表示⼩数点后显示的⼩数位数。

同时输出多个变量，%(a1,a2,a3)：

name = 'Seven'
age = 18
weight = 71.4
stu_id = 1
print('我的名字是%s，今年%d岁，体重%.2fkg，学号是%06d' % (name, age, weight, stu_id))

# 我的名字是Seven，今年18岁，体重71.40kg，学号是000001

2.4.2 f-字符串

f'{表达式}'

2.4.3 结束符

print ( ' 输出的内容 ' , end = "\n" )

在 Python 中， print() 默认⾃带 end="\n" 这个换⾏结束符，所以导致每两个 print 直接会换⾏展示，⽤户可以按需求更改结束符。

print ( ' 输出的内容 ' , end = "\t" )

2.5 输入

input ( " 提示信息 " )

输入函数input的特点：

当程序执⾏到 input ，等待⽤户输⼊，输⼊完成之后才继续向下执⾏。
在Python中， input 接收⽤户输⼊后，⼀般存储到变量，⽅便使⽤。
在Python中， input 会把接收到的任意⽤户输⼊的数据都当做字符串处理。

2.6 转换数据类型

input会把接收到的任意用户输入都当作字符串处理，因此要正确处理不同类型的数据，需要进行数据类型的转换。

函数	说明
int(x [,base ])	将 x转换为⼀个整数，其中 `base` 参数用于指定数字的进制，默认是10。 num = int("12", 8) # base 8 print(num) # 输出: 10 将字符串 `"12"` 视为一个八进制数。因此，`int("12", 8)` 的结果是十进制的`10`
float(x )	将 x 转换为⼀个浮点数
complex(real [,imag ])	创建⼀个复数， real 为实部， imag 为虚部，用j表示 com_i = complex(1, 4) print(com_i) # (1+4j)
str(x )	将对象 x 转换为字符串
repr(x)	用于返回一个对象的字符串表示形式。 - 字典： my_dict = {'name': 'Alice', 'age': 30} print(repr(my_dict)) # 输出: {'name': 'Alice', 'age': 30} - 自定义对象： class Person: def __init__(self, name, age): self.name = name self.age = age def __repr__(self): return f"Person(name={self.name}, age={self.age})" person = Person("Alice", 30) print(repr(person)) # 输出: Person(name=Alice, age=30) 总结： `repr(x)` 提供了对象的详细字符串表示，通常用于调试和记录。输出的字符串应该能够用来重建这个对象（如果可能）。对于自定义类，可以通过实现 `__repr__` 方法来定义对象的字符串表示形式。 class Person: def __init__(self, name, age): self.name = name self.age = age def __repr__(self): return f"P(name={self.name}, age={self.age})" person = Person("Alice", 30) print(repr(person)) # 输出: P(name=Alice, age=30)
eval(str)	`eval(str)` 函数用于将给定的字符串作为 Python 表达式进行求值，并返回求值结果。 x = 10 result = eval("x * 2") print(result) # 输出: 20 列表推导式： result = eval("[x**2 for x in range(5)]") print(result) # 输出: [0, 1, 4, 9, 16] 调用函数： def add(a, b): return a + b result = eval("add(5, 3)") print(result) # 输出: 8 安全风险：使用 `eval()` 时要小心，因为它可以执行任意代码。如果字符串来自不可信的来源，可能会导致安全问题。例如 user_input = "__import__('os').system('echo Hello, World!')" eval(user_input) # 如果 user_input 没有被安全处理，将执行该命令总结 `eval(str)` 用于将字符串作为 Python 表达式进行求值。它可以处理算术表达式、变量引用、列表推导式和函数调用。使用 `eval()` 时需谨慎，尤其是在处理不可信输入时，以避免安全风险。
tuple(s)	将序列 s 转换为⼀个元组
list(s)	将序列s转化为一个列表list
bin(x)	将⼀个整数转换为⼀个⼆进制字符串 `bin(x)` 是 Python 中的一个内置函数，用于将一个整数转换为其二进制字符串表示形式。返回值是以 `'0b'` 开头的字符串，表示这是一个二进制数。示例 1. 转换正整数: num = 10 binary_str = bin(num) print(binary_str) # 输出: 0b1010 2. 转换负整数: num = -10 binary_str = bin(num) print(binary_str) # 输出: -0b1010 3. 转换零: num = 0 binary_str = bin(num) print(binary_str) # 输出: '0b0' 总结 - `bin(x)` 将整数 `x` 转换为其二进制字符串形式。 - 返回的字符串以 `'0b'` 开头，表示这是一个二进制数。 - 可以处理正整数、负整数和零。

2.7 运算符

2.7.1 算术运算符

混合运算优先级顺序： () ⾼于 ** ⾼于 * / // % ⾼于 + -

2.7.2 赋值运算符

2.7.3 比较运算符

2.7.4 逻辑运算符

and 、or、not

2.8 条件语句

2.8.1 if 语法

2.8.2 if...else...

2.8.3 多重判断

2.8.4 三目运算符

条件成⽴执⾏的表达式 if 条件 else 条件不成⽴执⾏的表达式

2.9 循环

2.9.1 while循环

2.9.2 for 循环

2.9.3 break和continue

2.9.4 else

循环可以和 else 配合使⽤， else 下⽅缩进的代码指的是当循环正常结束之后要执⾏的代码。

while和for都可以配合else使⽤
else下⽅缩进的代码含义：当循环正常结束后执⾏的代码
break终⽌循环不会执⾏else下⽅缩进的代码
continue退出循环的⽅式执⾏else下⽅缩进的代码

1. while...else

2. 退出循环的方式 -- break

所谓else 指的是循环正常结束之后要执⾏的代码，即如果是 break终⽌循环的情况，else下⽅缩进的代码将不执⾏。

3. 退出循环的方式 -- continue

因为continue 是退出当前⼀次循环，继续下⼀次循环，所以该循环在 continue控制下是可以正常结束的，当循环结束后，则执⾏了 else 缩进的代码。

4. for...else

所谓else 指的是循环正常结束之后要执⾏的代码，即如果是 break 终⽌循环的情况，else下⽅缩进的代码将不执⾏。因为 continue 是退出当前⼀次循环，继续下⼀次循环，所以该循环在 continue 控制下是可以正常结束的，当循环结束后，则执⾏了 else 缩进的代码。

3. 字符串

3.1 下标

3.2 切片

序列 [ 开始位置下标 : 结束位置下标 : 步⻓ ]

1. 不包含结束位置下标对应的数据，正负整数均可；

2. 步⻓是选取间隔，正负整数均可，默认步⻓为 1.

name = "abcdefg"

print ( name [ 2 : 5 : 1 ]) # cde

print ( name [ 2 : 5 ]) # cde

print ( name [: 5 ]) # abcde

print ( name [ 1 :]) # bcdefg

print ( name [:]) # abcdefg

print ( name [:: 2 ]) # aceg

print ( name [: - 1 ]) # abcdef, 负 1 表示倒数第⼀个数据

print ( name [ - 4 : - 1 ]) # def

print ( name [:: - 1 ]) # gfedcba

3.3 常用操作方法

3.3.1 查找

find(): 检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则返回-1。

字符串序列.find(⼦串, 开始位置下标, 结束位置下标)

注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

mystr = "hello world and itcast and itheima and Python"

print ( mystr . find ( 'and' )) # 12

print ( mystr . find ( 'and' , 15 , 30 )) # 23

print ( mystr . find ( 'ands' )) # -1

index()：检测某个⼦串是否包含在这个字符串中，如果在返回这个⼦串开始的位置下标，否则则报异常。

字符串序列 . index ( ⼦串 , 开始位置下标 , 结束位置下标 )

注意：开始和结束位置下标可以省略，表示在整个字符串序列中查找。

mystr = "hello world and itcast and itheima and Python"

print ( mystr . index ( 'and' )) # 12

print ( mystr . index ( 'and' , 15 , 30 )) # 23

print ( mystr . index ( 'ands' )) # 报错

rfind() ：和 find() 功能相同，但查找⽅向为右侧开始。

rindex() ：和 index() 功能相同，但查找⽅向为右侧开始。

count() ：返回某个⼦串在字符串中出现的次数

字符串序列 . count ( ⼦串 , 开始位置下标 , 结束位置下标 )

mystr = "hello world and itcast and itheima and Python"

print ( mystr . count ( 'and' )) # 3

print ( mystr . count ( 'ands' )) # 0

print ( mystr . count ( 'and' , 0 , 20 )) # 1

3.3.2 修改

replace() ：替换

字符串序列 . replace ( 旧⼦串 , 新⼦串 , 替换次数 )

mystr = "hello world and itcast and itheima and Python"

# 结果： hello world he itcast he itheima he Python

print ( mystr . replace ( 'and' , 'he' ))

# 结果： hello world he itcast he itheima he Python

print ( mystr . replace ( 'and' , 'he' , 10 ))

# 结果： hello world and itcast and itheima and Python

print ( mystr )

注意：数据按照是否能直接修改分为可变类型和不可变类型两种。字符串类型的数据修改的时候不能改变原有字符串，属于不能直接修改数据的类型即是不可变类型。

split()：按照指定字符分割字符串。

字符串序列 . split ( 分割字符 , num )

注意： num 表示的是分割字符出现的次数，即将来返回数据个数为 num+1 个。

mystr = "hello world and itcast and itheima and Python"

# 结果： ['hello world ', ' itcast ', ' itheima ', ' Python']

print ( mystr . split ( 'and' ))

# 结果： ['hello world ', ' itcast ', ' itheima and Python']

print ( mystr . split ( 'and' , 2 ))

# 结果： ['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python']

print ( mystr . split ( ' ' ))

# 结果： ['hello', 'world', 'and itcast and itheima and Python']

print ( mystr . split ( ' ' , 2 ))

注意：如果分割字符是原有字符串中的⼦串，分割后则丢失该⼦串。

text = "Python is fun"
result = text.split("is") # 按" is "分割
print(result) # 输出: ['Python ', ' fun']

join() ：⽤⼀个字符或⼦串合并字符串，即是将多个字符串合并为⼀个新的字符串。

字符或⼦串 . join ( 多字符串组成的序列 )

list1 = [ 'chuan' , 'zhi' , 'bo' , 'ke' ]

t1 = ( 'aa' , 'b' , 'cc' , 'ddd' )

# 结果： chuan_zhi_bo_ke

print ( '_' . join ( list1 ))

# 结果： aa...b...cc...ddd

print ( '...' . join ( t1 ))

capitalize() ：将字符串第⼀个字符转换成⼤写。

`capitalize()` 是 Python 中的一个字符串方法，用于将字符串的第一个字符转换为大写字母，其余字符转换为小写字母。以下是一些示例来说明它的用法：

示例

1. **基本用法**:
```
text = "hello world"
result = text.capitalize()
print(result) # 输出: 'Hello world'
```

2. **字符串已经是大写**:
```
text = "PYTHON"
result = text.capitalize()
print(result) # 输出: 'Python'
```

3. **包含多种字符**:
```python
text = "pYtHoN Is FuN"
result = text.capitalize()
print(result) # 输出: 'Python is fun'
```

4. **字符串以数字开头**:
```python
text = "123abc"
result = text.capitalize()
print(result) # 输出: '123abc'（数字不会被转换）
```

5. **空字符串**:
```python
text = ""
result = text.capitalize()
print(result) # 输出: ''（仍然是空字符串）
```

总结

- `capitalize()` 方法将字符串的第一个字符转换为大写，其余字符转换为小写。
- 如果字符串以数字开头，数字不会受到影响。
- 对于空字符串，返回的仍然是空字符串。

title() ：将字符串每个单词⾸字⺟转换成⼤写。

`title()` 是 Python 中的一个字符串方法，用于将字符串中每个单词的首字母转换为大写字母，其余字母转换为小写字母。以下是一些示例来说明它的用法：

示例

1. **基本用法**:
```python
text = "hello world"
result = text.title()
print(result) # 输出: 'Hello World'
```

2. **包含多种字符**:
```python
text = "python is fun"
result = text.title()
print(result) # 输出: 'Python Is Fun'
```

3. **处理大写和小写**:
```python
text = "pYtHoN ProGrAmMiNg"
result = text.title()
print(result) # 输出: 'Python Programming'
```

4. **包含特殊字符和数字**:
```python
text = "hello world! welcome to python 101."
result = text.title()
print(result) # 输出: 'Hello World! Welcome To Python 101.'
```

5. **空字符串**:
```python
text = ""
result = text.title()
print(result) # 输出: ''（仍然是空字符串）
```

### 注意事项

- `title()` 方法会将每个单词的首字母转换为大写，但对于某些特殊情况（例如含有撇号的单词），可能不会按照预期处理。
- 例如，`"it's a test"` 将转换为 `"It'S A Test"`，而不是 `"It's A Test"`。

总结

- `title()` 方法用于将字符串中每个单词的首字母转换为大写。
- 适用于一般文本处理，但需注意特殊情况的处理。

lower() ：将字符串中⼤写转⼩写。

`lower()` 是 Python 中的一个字符串方法，用于将字符串中的所有大写字母转换为小写字母。以下是一些示例来说明它的用法：

### 示例

1. **基本用法**:
```python
text = "Hello World"
result = text.lower()
print(result) # 输出: 'hello world'
```

2. **字符串已经是小写**:
```python
text = "python"
result = text.lower()
print(result) # 输出: 'python'
```

3. **包含数字和特殊字符**:
```python
text = "Python 3.9 is Awesome!"
result = text.lower()
print(result) # 输出: 'python 3.9 is awesome!'
```

4. **处理混合大小写**:
```python
text = "PyThOn Is FuN"
result = text.lower()
print(result) # 输出: 'python is fun'
```

5. **空字符串**:
```python
text = ""
result = text.lower()
print(result) # 输出: ''（仍然是空字符串）
```

### 总结

- `lower()` 方法将字符串中的所有大写字母转换为小写字母。
- 适用于处理需要统一大小写的场景，如比较字符串或数据清洗等。
- 对于非字母字符（如数字和特殊字符），`lower()` 不会产生影响。

upper()：将字符串中⼩写转⼤写。
`upper()` 是 Python 中的一个字符串方法，用于将字符串中的所有小写字母转换为大写字母。以下是一些示例来说明它的用法：

### 示例

1. **基本用法**:
```python
text = "hello world"
result = text.upper()
print(result) # 输出: 'HELLO WORLD'
```

2. **字符串已经是大写**:
```python
text = "PYTHON"
result = text.upper()
print(result) # 输出: 'PYTHON'
```

3. **包含数字和特殊字符**:
```python
text = "Python 3.9 is awesome!"
result = text.upper()
print(result) # 输出: 'PYTHON 3.9 IS AWESOME!'
```

4. **处理混合大小写**:
```python
text = "PyThOn Is FuN"
result = text.upper()
print(result) # 输出: 'PYTHON IS FUN'
```

5. **空字符串**:
```python
text = ""
result = text.upper()
print(result) # 输出: ''（仍然是空字符串）
```

### 总结

- `upper()` 方法将字符串中的所有小写字母转换为大写字母。
- 适用于需要统一大小写的场景，例如数据比较、格式化输出等。
- 对于非字母字符（如数字和特殊字符），`upper()` 不会产生影响。

lstrip()：删除字符串左侧空⽩字符。
`lstrip()` 是 Python 中的一个字符串方法，用于删除字符串左侧（开头）的空白字符，包括空格、制表符（`\t`）和换行符（`\n`）。以下是一些示例来说明它的用法：

### 示例

1. **基本用法**:
```python
text = " Hello World"
result = text.lstrip()
print(result) # 输出: 'Hello World'
```

2. **删除制表符**:
```python
text = "\t\tPython is great"
result = text.lstrip()
print(result) # 输出: 'Python is great'
```

3. **删除多种空白字符**:
```python
text = " \t Hello, Python! "
result = text.lstrip()
print(result) # 输出: 'Hello, Python! '
```

4. **空字符串**:
```python
text = ""
result = text.lstrip()
print(result) # 输出: ''（仍然是空字符串）
```

5. **字符串没有空白字符**:
```python
text = "Hello World"
result = text.lstrip()
print(result) # 输出: 'Hello World'（没有变化）
```

### 总结

- `lstrip()` 方法用于删除字符串左侧的空白字符。
- 仅影响开头的空白字符，不会改变右侧的字符。
- 如果字符串的左侧没有空白字符，返回的字符串将保持不变。

rstrip()：删除字符串右侧空⽩字符。
`rstrip()` 是 Python 中的一个字符串方法，用于删除字符串右侧（结尾）的空白字符，包括空格、制表符（`\t`）和换行符（`\n`）。以下是一些示例来说明它的用法：

### 示例

1. **基本用法**:
```python
text = "Hello World "
result = text.rstrip()
print(result) # 输出: 'Hello World'
```

2. **删除制表符**:
```python
text = "Python is great\t\t"
result = text.rstrip()
print(result) # 输出: 'Python is great'
```

3. **删除多种空白字符**:
```python
text = " Hello, Python! \n"
result = text.rstrip()
print(result) # 输出: ' Hello, Python!'
```

4. **空字符串**:
```python
text = ""
result = text.rstrip()
print(result) # 输出: ''（仍然是空字符串）
```

5. **字符串没有空白字符**:
```python
text = "Hello World"
result = text.rstrip()
print(result) # 输出: 'Hello World'（没有变化）
```

### 总结

- `rstrip()` 方法用于删除字符串右侧的空白字符。
- 仅影响结尾的空白字符，不会改变左侧的字符。
- 如果字符串的右侧没有空白字符，返回的字符串将保持不变。

strip()：删除字符串两侧空⽩字符。
`strip()` 是 Python 中的一个字符串方法，用于删除字符串两侧（开头和结尾）的空白字符，包括空格、制表符（`\t`）和换行符（`\n`）。以下是一些示例来说明它的用法：

### 示例

1. **基本用法**:
```python
text = " Hello World "
result = text.strip()
print(result) # 输出: 'Hello World'
```

2. **删除制表符**:
```python
text = "\tPython is great\t"
result = text.strip()
print(result) # 输出: 'Python is great'
```

3. **删除多种空白字符**:
```python
text = " \nHello, Python! \n"
result = text.strip()
print(result) # 输出: 'Hello, Python!'
```

4. **空字符串**:
```python
text = ""
result = text.strip()
print(result) # 输出: ''（仍然是空字符串）
```

5. **字符串没有空白字符**:
```python
text = "Hello World"
result = text.strip()
print(result) # 输出: 'Hello World'（没有变化）
```

### 总结

- `strip()` 方法用于删除字符串两侧的空白字符。
- 影响开头和结尾的空白字符，不会改变字符串中间的字符。
- 如果字符串两侧没有空白字符，返回的字符串将保持不变。

ljust() ：返回⼀个原字符串左对⻬ , 并使⽤指定字符 ( 默认空格 )填充⾄对应⻓度的新字符串。
`ljust()` 是 Python 中的一个字符串方法，用于返回一个新的字符串，该字符串是原字符串左对齐的，并使用指定的字符（默认为空格）填充到指定的长度。以下是一些示例来说明它的用法：

### 示例

1. **基本用法**:
```python
text = "Hello"
result = text.ljust(10) # 默认用空格填充
print(result) # 输出: 'Hello '（后面有5个空格）
```

2. **指定填充字符**:
```python
text = "Python"
result = text.ljust(10, '*') # 使用 '*' 填充
print(result) # 输出: 'Python****'
```

3. **长度小于原字符串**:
```python
text = "Hello, World!"
result = text.ljust(5) # 指定长度小于原字符串
print(result) # 输出: 'Hello, World!'（没有变化，因为长度大于5）
```

4. **使用不同的填充字符**:
```python
text = "Data"
result = text.ljust(10, '-') # 使用 '-' 填充
print(result) # 输出: 'Data------'
```

5. **空字符串的填充**:
```python
text = ""
result = text.ljust(5) # 用空格填充
print(result) # 输出: ' '（5个空格）
```

### 总结

- `ljust(width, fillchar)` 方法用于返回一个左对齐的字符串，长度为 `width`。
- 如果原字符串的长度大于或等于 `width`，将返回原字符串。
- 可以指定填充字符，默认为空格。

rjust() ：返回⼀个原字符串右对⻬ , 并使⽤指定字符 ( 默认空格 )填充⾄对应⻓度的新字符串，语法和 ljust()相同。
`rjust()` 是 Python 中的一个字符串方法，用于返回一个新的字符串，该字符串是原字符串右对齐的，并使用指定的字符（默认为空格）填充到指定的长度。以下是一些示例来说明它的用法：

### 示例

1. **基本用法**:
```python
text = "Hello"
result = text.rjust(10) # 默认用空格填充
print(result) # 输出: ' Hello'（前面有5个空格）
```

2. **指定填充字符**:
```python
text = "Python"
result = text.rjust(10, '*') # 使用 '*' 填充
print(result) # 输出: '****Python'
```

3. **长度小于原字符串**:
```python
text = "Hello, World!"
result = text.rjust(5) # 指定长度小于原字符串
print(result) # 输出: 'Hello, World!'（没有变化，因为长度大于5）
```

4. **使用不同的填充字符**:
```python
text = "Data"
result = text.rjust(10, '-') # 使用 '-' 填充
print(result) # 输出: '------Data'
```

5. **空字符串的填充**:
```python
text = ""
result = text.rjust(5) # 用空格填充
print(result) # 输出: ' '（5个空格）
```

### 总结

- `rjust(width, fillchar)` 方法用于返回一个右对齐的字符串，长度为 `width`。
- 如果原字符串的长度大于或等于 `width`，将返回原字符串。
- 可以指定填充字符，默认为空格，功能与 `ljust()` 类似，但方向相反。

center() ：返回⼀个原字符串居中对⻬ , 并使⽤指定字符 ( 默认空格 )填充⾄对应⻓度的新字符串，语法和 ljust() 相同。

`center()` 是 Python 中的一个字符串方法，用于返回一个新的字符串，该字符串是原字符串居中对齐的，并使用指定的字符（默认为空格）填充到指定的长度。以下是一些示例来说明它的用法：

### 示例

1. **基本用法**:
```python
text = "Hello"
result = text.center(10) # 默认用空格填充
print(result) # 输出: ' Hello '（前后各填充2个空格）
```

2. **指定填充字符**:
```python
text = "Python"
result = text.center(10, '*') # 使用 '*' 填充
print(result) # 输出: '**Python**'
```

3. **长度小于原字符串**:
```python
text = "Hello, World!"
result = text.center(5) # 指定长度小于原字符串
print(result) # 输出: 'Hello, World!'（没有变化，因为长度大于5）
```

4. **使用不同的填充字符**:
```python
text = "Data"
result = text.center(10, '-') # 使用 '-' 填充
print(result) # 输出: '--Data----'
```

5. **空字符串的填充**:
```python
text = ""
result = text.center(5) # 用空格填充
print(result) # 输出: ' '（5个空格）
```

### 总结

- `center(width, fillchar)` 方法用于返回一个居中对齐的字符串，长度为 `width`。
- 如果原字符串的长度大于或等于 `width`，将返回原字符串。
- 可以指定填充字符，默认为空格，适用于需要居中显示的场景。

3.3.3 判断

所谓判断即是判断真假，返回的结果是布尔型数据类型： True 或 False 。

startswith()：检查字符串是否是以指定⼦串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

字符串序列.startswith(⼦串, 开始位置下标, 结束位置下标)

`startswith()` 是 Python 中的一个字符串方法，用于检查字符串是否以指定的子串开头。如果是，则返回 `True`，否则返回 `False`。可以选择性地设置开始和结束位置下标，以在指定范围内进行检查。

### 示例

1. **基本用法**:
```python
text = "Hello, World!"
result = text.startswith("Hello")
print(result) # 输出: True
```

2. **检查不同的子串**:
```python
text = "Hello, World!"
result = text.startswith("World")
print(result) # 输出: False
```

3. **使用开始和结束位置**:
```python
text = "Hello, World!"
result = text.startswith("World", 7) # 从索引 7 开始检查
print(result) # 输出: True
```

4. **指定结束位置**:
```python
text = "Hello, World!"
result = text.startswith("Hello", 0, 5) # 在索引 0 到 5 范围内检查
print(result) # 输出: True
```

5. **检查空字符串**:
```python
text = ""
result = text.startswith("Hello")
print(result) # 输出: False
```

### 总结

- `startswith(prefix, start=0, end=len(string))` 方法用于检查字符串是否以指定的子串开头。
- 可以指定开始和结束位置，以在特定范围内进行检查。
- 返回值为布尔类型：如果以指定子串开头，则返回 `True`，否则返回 `False`。

endswith() ：：检查字符串是否是以指定⼦串结尾，是则返回 True ，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
`endswith()` 是 Python 中的一个字符串方法，用于检查字符串是否以指定的子串结尾。如果是，则返回 `True`，否则返回 `False`。可以选择性地设置开始和结束位置下标，以在指定范围内进行检查。

### 示例

1. **基本用法**:
```python
text = "Hello, World!"
result = text.endswith("World!")
print(result) # 输出: True
```

2. **检查不同的子串**:
```python
text = "Hello, World!"
result = text.endswith("Hello")
print(result) # 输出: False
```

3. **使用开始和结束位置**:
```python
text = "Hello, World!"
result = text.endswith("Hello", 0, 5) # 在索引 0 到 5 范围内检查
print(result) # 输出: True
```

4. **指定结束位置**:
```python
text = "Hello, World!"
result = text.endswith("World", 7) # 从索引 7 开始检查
print(result) # 输出: True
```

5. **检查空字符串**:
```python
text = ""
result = text.endswith("World!")
print(result) # 输出: False
```

### 总结

- `endswith(suffix, start=0, end=len(string))` 方法用于检查字符串是否以指定的子串结尾。
- 可以指定开始和结束位置，以在特定范围内进行检查。
- 返回值为布尔类型：如果以指定子串结尾，则返回 `True`，否则返回 `False`。

isalpha() ：如果字符串⾄少有⼀个字符并且所有字符都是字⺟则返回 True, 否则返回 False 。

isdigit() ：如果字符串只包含数字则返回 True 否则返回 False 。

isalnum() ：如果字符串⾄少有⼀个字符并且所有字符都是字⺟或数字则返回 True, 否则返回

False 。

`isalnum()` 是 Python 中的一个字符串方法，用于检查字符串是否只包含字母和数字，并且至少有一个字符。如果字符串满足这些条件，则返回 `True`，否则返回 `False`。

### 示例

1. **基本用法**:
```python
text = "Hello123"
result = text.isalnum()
print(result) # 输出: True
```

2. **包含空格**:
```python
text = "Hello 123"
result = text.isalnum()
print(result) # 输出: False（包含空格）
```

3. **包含特殊字符**:
```python
text = "Hello@123"
result = text.isalnum()
print(result) # 输出: False（包含特殊字符）
```

4. **只包含字母**:
```python
text = "Hello"
result = text.isalnum()
print(result) # 输出: True
```

5. **只包含数字**:
```python
text = "123456"
result = text.isalnum()
print(result) # 输出: True
```

6. **空字符串**:
```python
text = ""
result = text.isalnum()
print(result) # 输出: False（没有字符）
```

### 总结

- `isalnum()` 方法用于检查字符串是否只包含字母和数字，并且至少有一个字符。
- 如果字符串只由字母和数字组成且不为空，则返回 `True`；否则返回 `False`。