恭喜您决定参加为期30 天的 Python编程挑战赛。在这个挑战中，您将学习成为 Python 程序员所需的一切以及整个编程概念。在挑战结束时，您将获得30DaysOfPython编程挑战证书。

1、第一天-介绍

Python 是一种用于通用编程的高级编程语言。它是一种开源、解释型、面向对象的编程语言。Python 是由荷兰程序员 Guido van Rossum 创建的。Python 编程语言的名称来源于英国的小品喜剧系列《Month Python’s Flying Circus》。第一个版本于 1991 年 2 月 20 日发布。这个为期 30 天的 Python 挑战将帮助您逐步学习最新版本的 Python，Python 3。

这个挑战是为想要学习 Python 编程语言的初学者设计的。完成挑战可能需要30到100天，主要看个人能力，逻辑思维好的可能30天就能学会。

1.1为什么是 Python？

它是一种非常接近人类语言的编程语言，因此易于学习和使用，Python 被各种行业和公司（包括 Google）使用，它已被用于开发 Web 应用程序、桌面应用程序、系统管理和机器学习库。

1.2环境设置

安装 Python

要运行 python 脚本，您需要安装 python。让我们下载python。如果您是 Windows 用户。单击红色圈出的按钮。

如果您是 macOS 用户。单击红色圈出的按钮。

要检查是否安装了 python，请在设备终端上写入以下命令。

Python–版本

从终端可以看出，我目前使用的是Python 3.7.5版本。您的 Python 版本可能与我的不同，应该是 3.6 或更高版本。如果你能看到 python 版本，那就太好了。Python 已安装在您的机器上。继续下一节。

Python Shell

Python 是一种解释性脚本语言，因此不需要编译。这意味着它逐行执行代码。Python 自带一个Python Shell（Python Interactive Shell）。它用于执行单个 python 命令并获取结果。

Python Shell 等待来自用户的 Python 代码。当您输入代码时，它会解释代码并在下一行显示结果。打开终端或命令提示符（cmd）并写入：

Python

Python 交互式 shell 已打开，它正在等待您编写 Python 脚本。您将在此符号 >>> 旁边编写 Python 脚本，然后单击 Enter。让我们在 Python 脚本 shell 上编写我们的第一个脚本。

上面一步完成后，可以在 Python 交互式 shell 上编写了第一个 Python 脚本。我们如何关闭 Python 交互式 shell？要关闭 shell，请在此符号旁边 >> 写exit()命令并按 Enter。

现在，您知道如何打开 Python 交互式 shell 以及如何退出它。

如果您编写 Python 理解的脚本，Python 会给您结果，否则返回错误。让我们故意犯一个错误， Python 会返回出无效的语法错误。

从返回的错误中可以看出，Python 非常聪明，它知道我们犯的错误是Syntax Error: invalid syntax。在 Python 中使用 x 作为乘法是一个语法错误，因为 x 在 Python 中不是有效的语法。我们使用星号 *代替 x 进行乘法。返回的错误清楚地显示了要修复的内容。

从程序中识别和消除错误的过程称为调试。让我们用 * 代替x来调试它。

修复语法错误

我们的错误被修复了，代码运行了，我们得到了我们期望的结果。作为程序员，您每天都会看到此类错误，一定要善于调试，要了解您面临的错误类型。有时你可能会遇到的错误是SyntaxError错误，IndexError，NameError，ModuleNotFoundError，KeyError异常，导入错误，AttributeError错误，类型错误，ValueError异常，ZeroDivisionError等。

让我们多练习一下如何使用 Python 交互式 shell。转到您的终端或命令提示符并输入单词python。

Python 交互式 shell 已打开。让我们做一些基本的数学运算加、减、乘、除、模、指数。

在编写任何 Python 代码之前，让我们先做一些数学运算：

2 + 3 = 5
3 - 2 = 1
3 * 2 = 6
3 / 2 = 1.5
3 ^ 2 = 3 x 3 = 9

在python中，我们有以下附加操作：

3 % 2 = 1 => 表示求余数
3 // 2 = 1 => 这意味着去除余数

我们把上面的数学表达式改成 Python 代码，在 shell 的最开始写一个注释。

我们可以在我们的代码中留下一些文本，让我们的代码更具可读性，python 中的注释以 hash# 符号开头。

 #注释以 hash 开头
 #这是一条 Python 注释，因为它以 (#) 符号开头

python shell上的数学

在shell上写exit()关闭打开的shell，再打开，练习如何在Python shell上写文本。

在 python shell 上写字符串

1.3Python基础

Python 语法

Python 脚本可以在 Python shell 或代码编辑器中编写。Python 文件的扩展名为 .py。

Python 缩进

缩进是文本中的空白。许多语言都使用缩进来提高代码可读性，但是 Python 使用缩进来创建代码块。在其他编程语言中，大括号用于创建代码块而不是缩进。编写python代码时的常见错误之一是缩进错误。

注释

注释对于使代码更具可读性以及在我们的代码中留下注释非常重要。Python 不会运行我们代码的注释部分。Python 中任何以 hash(#) 开头的文本都是注释。

示例：单行注释

#这是第一条评论
#这是第二条评论
# Python 正在吞噬世界

示例：多行注释

如果未分配给变量，则三重引号可用于多行注释

" " "这是多行注释
多行注释需要多行
。python 正在吃掉世界
" " "

数据类型

在 Python 中有几种类型的数据类型。让我们从最常见的开始。其他部分将详细介绍不同的数据类型。目前，让我们通过不同的数据类型并熟悉它们。

数字

• 整数：整数（负、零和正）数 示例：… -3, -2, -1, 0, 1, 2, 3 …
• 浮点数：十进制数 示例 … -3.5, -2.25, -1.0, 0.0, 1.1, 2.2, 3.5 …
• 复杂示例 1 + j, 2 + 4j

细绳
单引号或双引号下的一个或多个字符的集合。如果一个字符串不止一个句子，那么我们使用三重引号。

例子：

'Asabeneh' 
'芬兰' 
'Python' 
'我喜欢教学' 
'我希望你享受 30DaysOfPython 挑战赛的第一天'

布尔值
布尔数据类型是 True 或 False 值。T 和 F 应始终为大写。

例子：

   True   # 灯亮了吗？如果
    灯亮，则值为 True False  # 灯亮了吗？如果关闭，则值为 False

列表
Python 列表是一个有序集合，它允许存储不同的数据类型项。列表类似于 JavaScript 中的数组。

例子：

[ 0 , 1 , 2 , 3 , 4 , 5 ]   # 都是相同的数据类型 - 数字列表
[ 'Banana' , 'Orange' , 'Mango' , 'Avocado' ] # 所有相同的数据类型 - a字符串列表（水果） 
[ 'Finland' , 'Estonia' , 'Sweden' , 'Norway' ] # 所有相同的数据类型 - 字符串列表（国家） 
[ 'Banana' , 10 , False , 9.81 ]# 列表中的不同数据类型 - 字符串、整数、布尔值和浮点数

字典
Python 字典对象是键值对格式的无序数据集合。

例子：

{
 'first_name' : 'Asabeneh' ,
 'last_name' : 'Yetayeh' ,
 'country' : 'Finland' , 
 'age' : 250 , 
 'is_married' : True ,
 'skills' :[ 'JS' , 'React' , '节点'，'Python' ]
}

元组
元组是不同数据类型（如列表）的有序集合，但元组一旦创建就无法修改。它们是不可变的。

例子：

( 'Asabeneh' , 'Pawel' , 'Brook' , 'Abraham' , 'Lidiya' ) # 名字

（“地球”、“木星”、“海王星”、“火星”、“金星”、“土星”、“天王星”、“水星”）#行星
放

集合
集合是类似于列表和元组的数据类型的集合。与列表和元组不同，集合不是项目的有序集合。就像在数学中一样，Python 中的 set 只存储唯一的项目。

在后面的部分中，我们将详细介绍每种 Python 数据类型。

例子：

{ 2 , 4 , 3 , 5 }
{ 3.14 , 9.81 , 2.7 } # 顺序在集合中并不重要

检查数据类型

要检查某些数据/变量的数据类型，我们使用type函数。在以下终端中，您将看到不同的 Python 数据类型：

Python文件

首先打开你的项目文件夹，30DaysOfPython。如果您没有此文件夹，请创建一个名为 30DaysOfPython 的文件夹。在此文件夹中，创建一个名为 helloworld.py 的文件。

Python shell 在不使用print 的情况下进行打印，查看我们的结果，我们应该使用内置函数 *print()。在打印（）内置函数有一个或多个参数如下印刷（“arument1”，“参数2”，“参数3”） 。请参阅下面的示例。

例子：

文件名为 helloworld.py

# 第 1 天 - 30DaysOfPython 挑战

print ( 2  +  3 )              #加法(+) 
print ( 3  -  1 )              #减法(-) 
print ( 2  *  3 )              #乘法(*) 
print ( 3  /  2 )              # 除法(/) 
print ( 3  **  2 ) )             # 指数(**)
打印( 3  %  2 )              # 模数(%)
打印( 3  //  2)             # 楼层除法运算符(//)

# 检查数据类型
print ( type ( 10 ))           # Int 
print ( type ( 3.14 ))         # Float 
print ( type ( 1  +  3j ))       # Complex number 
print ( type ( 'Asabeneh' ))   # String 
print ( type ([ 1 , 2 , 3 ]))    # List 
print ( type ({ 'name' : 'Asabeneh'})) # 字典
打印( type ({ 9.8 , 3.14 , 2.7 }))     # 设置
打印( type (( 9.8 , 3.14 , 2.7 )))     # 元组

要运行 python 文件，请检查下图。您可以通过在 Visual Studio Code 上运行绿色按钮或在终端中键入python helloworld.py来运行 python 文件。

你真了不起。您刚刚完成了第 1 天的挑战，正在走向伟大。

第 2 天 - 变量、内置函数

2.1内置函数

在 Python 中，我们有很多内置函数。内置函数可供您全局使用，这意味着您无需导入或配置即可使用内置函数。一些最常用的 Python 内置函数如下：print()、len()、type()、int()、float()、str()、input()、list()、dict()、min()、max()、sum()、sorted()、open()、file()、help()和dir(). 在下表中，您将看到取自python 文档的 Python 内置函数的详尽列表。

让我们打开 Python shell 并开始使用一些最常见的内置函数。

让我们通过使用不同的内置函数来练习更多

从上面的终端可以看出，Python 有保留字。我们不使用保留字来声明变量或函数。我们将在下一节介绍变量。

我相信，现在您已经熟悉内置函数了。让我们再做一次内置函数的练习，我们将继续下一节。

2.2变量

变量将数据存储在计算机内存中。推荐在许多编程语言中使用助记变量。助记变量是易于记忆和关联的变量名称。变量是指存储数据的内存地址。命名变量时不允许以数字开头、特殊字符、连字符。变量可以有一个简短的名称（如 x、y、z），但强烈建议使用更具描述性的名称（名字、姓氏、年龄、国家/地区）。

Python 变量名规则

• 变量名必须以字母或下划线字符开头
• 变量名不能以数字开头
• 变量名称只能包含字母数字字符和下划线（Az、0-9 和 _ ）
• 变量名区分大小写（firstname、Firstname、FirstName 和 FIRSTNAME）是不同的变量）

让我们设置有效的变量名

名
姓
年龄
国家
城市
名
姓
首都_城市
_if #如果我们想使用保留字作为变量
年_2021
2021年
当前_year_2021
出生年
编号 1
数量 2

无效的变量名

名
名
第一个$name
数字 1
1号

我们将使用许多 Python 开发人员采用的标准 Python 变量命名风格。Python 开发人员使用蛇形大小写（snake_case）变量命名约定。对于包含多个单词的变量（例如 first_name、last_name、engine_rotation_speed），我们在每个单词后面使用下划线字符。下面的例子是一个标准的变量命名示例，当变量名超过一个单词时需要下划线。

当我们为变量分配某种数据类型时，称为变量声明。例如，在下面的示例中，我的名字被分配给变量 first_name。等号是赋值运算符。赋值意味着将数据存储在变量中。Python 中的等号与数学中的等号不同。

例子：

＃在Python变量
FIRST_NAME  =  'Asabeneh'
姓氏 =  'Yetayeh'
国家 =  '芬兰
城市 =  '赫尔辛基'
年龄 =  250 
is_married  = 真
技能 = [ 'HTML' ，'CSS' ，'JS' ，'阵营'，' Python' ]
 person_info  = {
    'firstname' : 'Asabeneh' ,
    'lastname' : 'Yetayeh' ,
    '国家' ：'芬兰',
    '城市' : '赫尔辛基' 
   }

让我们使用print()和len()内置函数。打印函数采用无限数量的参数。参数是我们可以传递或放入函数括号内的值，请参见下面的示例。

例子：

print ( 'Hello, World!' ) # 文本 Hello, World! 是一个参数
print ( 'Hello' , ',' , 'World' , '!' ) # 它可以接受多个参数，已经传递了四个参数
print ( len ( 'Hello, World!' )) # 它只需要一个争论

让我们打印并找出在顶部声明的变量的长度：

例子：

打印（'名字长度：'，first_name）
打印（'名字长度：'，len（first_name））
打印（'姓氏：'，last_name）
打印（'姓氏长度：'，len（last_name））
打印（'国家：'，国家）
打印（'城市：'，城市）
打印（'年龄：'，年龄）
打印（'已婚：' , is_married )
打印( '技能: ' ,技能)
打印( '个人信息: ' , person_info )

2.3在一行中声明多个变量

也可以在一行中声明多个变量：

例子：

first_name , last_name , country , age , is_married  =  'Asabeneh' , 'Yetayeh' , 'Helsink' , 250 , True

打印（FIRST_NAME，姓氏，国家，年龄，is_married）
打印（'名字：'，FIRST_NAME）
打印（'姓：'，姓氏）
打印（'国家：'，国家）
打印（'年龄：'，年龄）
打印（'已婚：'，is_已婚）

使用input()内置函数获取用户输入。让我们将从用户那里获得的数据分配给 first_name 和 age 变量。
例子：

first_name  =  input ( '你叫什么名字：' )
 age  =  input ( '你多大了？'）

打印（名字）
打印（年龄）

2.4数据类型

Python 中有多种数据类型。为了识别数据类型，我们使用type内置函数。我想请你专注于很好地理解不同的数据类型。说到编程，全都与数据类型有关。我一开始就介绍了数据类型，它又来了，因为每个主题都与数据类型有关。我们将在它们各自的部分中更详细地介绍数据类型。

2.5检查数据类型和转换

• 检查数据类型：要检查某些数据/变量的数据类型，我们使用类型
  示例：

# 不同的python 数据类型
# 让我们声明不同数据类型的变量

first_name  =  'Asabeneh'      # str 
last_name  =  'Yetayeh'        # str 
country  =  'Finland'          # str 
city =  'Helsinki'             # str 
age  =  250                    # int，这不是我的真实年龄，别担心

# 打印类型
print ( type ( 'Asabeneh' ))      # str 
print ( type ( first_name ))      # str 
print ( type ( 10 ))              # int 
print ( type ( 3.14 ))            # float 
print ( type ( 1  +  1j ) )          # complex 
print ( type ( True ))            # bool 
print ( type([ 1 , 2 , 3 , 4 ]))      # list 
print ( type ({ 'name' : 'Asabeneh' , 'age' : 250 , 'is_married' : 250 }))     # dict 
print ( type (( 1 , 2 )))                                               # 元组
打印( type ( zip ([ 1 , 2 ],[ 3 , 4])))                                    # 设置

• 转换：将一种数据类型转换为另一种数据类型。我们使用int() , float() , str() , list , set
  当我们进行算术运算时，字符串数字应该首先转换为 int 或 float
  ，否则会返回错误。如果我们把一个数字和一个字符串连接起来，这个数字应该首先被转换成一个字符串。我们将在字符串部分讨论连接。

例子：

# int to float 
num_int  =  10 
print ( 'num_int' , num_int )          # 10 
num_float  =  float ( num_int )
 print ( 'num_float:' , num_float )    # 10.0

# 浮到 int
重力 =  9.81
打印( int ( gravity ))              # 9

# int to str 
num_int  =  10 
print ( num_int )                   # 10 
num_str  =  str ( num_int )
 print ( num_str )                   # '10'

# str to int or float 
num_str  =  '10.6' 
print ( 'num_int' , int ( num_str ))       # 10 
print ( 'num_float' , float ( num_str ))   # 10.6

# str to list 
first_name  =  'Asabeneh' 
print ( first_name )                # 'Asabeneh' 
first_name_to_list  =  list ( first_name )
 print ( first_name_to_list )             # ['A', 's', 'a', 'b', 'e', ' n', 'e', 'h']

2.6数字

Python 中的数字数据类型：

1. 整数：整数（负、零和正）数 示例：… -3, -2, -1, 0, 1, 2, 3 …
2. 浮点数（十进制数） 示例：… -3.5, -2.25, -1.0, 0.0, 1.1, 2.2, 3.5 …
3. 复数示例：1 + j、2 + 4j、1 - 1j

🌕你太棒了。您刚刚完成了第 2 天的挑战，您在通往伟大的道路上领先了两步。

第 3 天 - 运算符

3.1布尔值

布尔数据类型表示两个值之一：True或False。一旦我们开始使用比较运算符，这些数据类型的使用就会很清楚。与 JavaScript 不同，True的第一个字母T和False 的F应该大写。
示例：

打印（真）
打印（假）

3.2运营商

Python 语言支持多种类型的运算符。在本节中，我们将重点介绍其中的几个。

3.3赋值运算符

赋值运算符用于为变量赋值。让我们以 = 为例。数学中的等号表示两个值是相等的，但是在 Python 中这意味着我们将一个值存储在某个变量中，我们称之为赋值或赋值给变量。下表显示了不同类型的 python 赋值运算符。

3.4算术运算符：

• 加法（+）：a + b
• 减法（-）：a - b
• 乘法（*）：a * b
• 除法（/）：a / b
• 模量(%): a % b
• 楼层划分(//): a // b
• 求幂（**）：a ** b

3.5算术运算符

示例：整数

# Python 中的算术运算
# 整数

print ( 'Addition: ' , 1  +  2 )         # 3 
print ( 'Subtraction: ' , 2  -  1 )      # 1 
print ( 'Multiplication: ' , 2  *  3 )   # 6 
print ( 'Division: ' , 4  /  2 )        # Python 中的 2.0 Division 给出浮点数
print ( 'Division: ' , 6  /  2 )         # 3.0          
print ('Division: ' , 7  /  2 )         # 3.5 
print ( 'Division without the余数: ' , 7  //  2 )    # 3, 给出不带浮点数或不带余数
打印( 'Division without the余数: ' , 7  / /  3 )    # 2 
print ( 'Modulus: ' , 3  %  2 )          # 1, 给出余数
print ( 'Exponentiation: ' , 2  **  3 )# 9 表示 2 * 2 * 2

示例：浮点数

# 浮点数
print ( 'Floating Point Number, PI' , 3.14 )
 print ( 'Floating Point Number, Gravity' , 9.81 )

示例：复数

# 复数
print ( 'Complex number: ' , 1  +  1j )
 print ( 'Multiplying complex numbers: ' ,( 1  +  1j ) * ( 1  -  1j ))

让我们声明一个变量并分配一个数字数据类型。我将使用单字符变量，但请记住不要养成声明此类变量的习惯。变量名应该一直是助记符。

例子：

# 首先声明顶部的变量

a  =  3  # a 是变量名，3 是整数数据类型
b  =  2  # b 是变量名，3 是整数数据类型

# 算术运算并将结果赋值给变量
total  =  a  +  b 
diff  =  a  -  b 
product  =  a  *  b
除法 =  a  /  b
余数 =  a  %  b 
floor_division  =  a  //  b
指数 =  a  **  b

# 我应该使用 sum 而不是 total 但 sum 是一个内置函数 - 尽量避免覆盖内置函数
print ( total ) # 如果你没有用一些字符串标记你的打印，你永远不知道结果在哪里from 
print ( 'a + b = ' , total )
 print ( 'a - b = ' , diff )
 print ( 'a * b = ' , product )
 print ( 'a / b = ' ,除法)
 print ( 'a % b = ' ,余数)
打印('a // b = ' , floor_division )
打印( 'a ** b = ' ,求幂)
例子：

打印（'==加法，减法，乘法，除法，模数=='）

# 声明值并将它们组织在一起
num_one  =  3 
num_two  =  4

# 算术运算
total  =  num_one  +  num_two 
diff  =  num_two  -  num_one 
product  =  num_one  *  num_two 
div  =  num_two  /  num_one
余数 =  num_two  %  num_one

# 用标签
打印值print ( 'total:' , total )
 print ( 'difference:' , diff )
 print ( 'product:' , product )
 print ( 'division:' , div )
 print ( 'remainder:' , remason )

让我们开始连接点并开始利用我们已知的计算（面积、体积、密度、重量、周长、距离、力）。

例子：

# 计算圆的面积
radius  =  10                                  #
圆的半径area_of_circle  =  3.14  *  radius  **  2          # 两个 * 符号表示指数或幂
print ( 'Area of​​ a circle:' , area_of_circle )

# 计算矩形的面积
length  =  10 
width  =  20 
area_of_rectangle  =  length  *  width 
print ( 'Area of​​ rectangle:' , area_of_rectangle )

＃计算的物体的重量
的质量 =  75
重力 =  9.81
重量 = 质量 * 重力
打印（重量，“N”）                          ＃添加单元的重量

# 计算液体
质量 的密度=  75  # 公斤
体积 =  0.075  # 立方米
密度 = 质量 / 体积 # 1000 Kg/m^3

3.6比较运算符

在编程中我们比较值，我们使用比较运算符来比较两个值。我们检查一个值是否大于或小于或等于其他值。

示例：比较运算符

print ( 3  >  2 )      # 真，因为 3 大于 2 
print ( 3  >=  2 )     # 真，因为 3 大于 2 
print ( 3  <  2 )      # 假，因为 3 大于 2 
print ( 2  <  3 )      # 真，因为 2 小于 3 
print ( 2  <=  3 )     # 真，因为 2 小于 3 
print ( 3  ==  2 )     # 假，因为 3 不等于 2
print ( 3  !=  2 )     # 真，因为 3 不等于 2 
print ( len ( 'mango' ) ==  len ( 'avocado' ))   # False 
print ( len ( 'mango' ) !=  len ( 'avocado ' ))   # True 
print ( len ( 'mango' ) <  len ( 'avocado' ))    # True 
print ( len ( 'milk' ) != len ( 'meat' ))       # False 
print ( len ( 'milk' ) ==  len ( 'meat' ))       # True 
print ( len ( 'tomato' ) ==  len ( 'potato' ))   # True 
print ( len ( 'python' ) >  len ( 'dragon' ))    # 假


# 比较某事给出真或假

打印（'真==真：'，真 == 真）
打印（'真==假：'，真 == 假）
打印（'假==假：'，假 == 假）

除了上述比较运算符之外，Python 还使用：

• is：如果两个变量是同一个对象，则返回 true（x 是 y）
• is not：如果两个变量不是同一个对象，则返回 true（x 不是 y）
• in：如果查询列表包含某个项目（x in y），则返回 True
• not in：如果查询的列表没有某个项目（x in y），则返回 True

print ( '1 is 1' , 1  is  1 )                    # True - 因为数据值是相同的
print ( '1 is not 2' , 1  is  not  2 )            # True - 因为 1 is not 2 
print ( 'A in Asabeneh ' , 'A'  in  'Asabeneh' ) # True - A 在字符串中找到
print ( 'B in Asabeneh' , 'B'  in  'Asabeneh' ) # False - 没有大写的 B 
print ( 'coding' 在 'coding for all' ) # True - 因为对 all 进行编码有单词 coding 
print ( 'a in an:' , 'a'  in  'an' )       # True 
print ( '4 is 2 ** 2:' , 4  is  2  **  2 )    # 真

3.7逻辑运算符

与其他编程语言不同，python 使用关键字and , or and not用于逻辑运算符。逻辑运算符用于组合条件语句：

print ( 3  >  2  and  4  >  3 ) # True - 因为两个语句都是真的
print ( 3  >  2  and  4  <  3 ) # False - 因为第二个语句是假的
print ( 3  <  2  and  4  <  3 ) # False -因为这两个语句都是假的
print ( 'True and True: ' , True  and  True )
 print ( 3  >  2  or  4 >  3 )   # True - 因为两个陈述都是真的
print ( 3  >  2  or  4  <  3 )   # True - 因为其中一个陈述是真的
print ( 3  <  2  or  4  <  3 )   # False - 因为两个陈述都是假的
print ( 'True or False:' , True  or  False )
 print ( not  3  >  2 )      # False - 因为 3 > 2 为真，那么 not True 给出 False 
print (not  True )       # False - 否定，not 运算符将 true 变为 false 
print ( not  False )      # True 
print ( not  not  True )   # True 
print ( not  not  False ) # False

🌕你有无限的能量。您刚刚完成了第 3 天的挑战，您在通往伟大的道路上领先了三步。

第 4 天 - 字符串

文本是一种字符串数据类型。任何写成文本的数据类型都是字符串。单引号、双引号或三引号下的任何数据都是字符串。有不同的字符串方法和内置函数来处理字符串数据类型。要检查字符串的长度，请使用 len() 方法。

4.1创建字符串

letter  =  'P'                 # 字符串可以是单个字符或一堆文本
print ( letter )                # P 
print ( len ( letter ))           # 1 
greeting  =  'Hello, World!'   # 字符串可以使用单引号或双引号"Hello, World!" 
打印（问候）              #你好，世界！
print ( len ( greeting ))         # 13 
sentence  =  "我希望你享受 Python 挑战的 30 天" 
print (句子）

多行字符串是通过使用三重单引号 (’’’) 或三重双引号 (""") 创建的。请参见下面的示例。

multiline_string  =  '''我是一名老师，喜欢教学。
我发现没有什么比赋予人们权力更有价值的事情了。
这就是为什么我创建了 30 天的 python.''' 
print ( multiline_string )

# 做同样事情的另一种方式
multiline_string  =  """我是一名老师，喜欢教书。
我没有发现任何事情比赋予人们权力更有价值。
这就是我创建 30 天 Python 的原因。""" 
print ( multiline_string )

4.2字符串连接

我们可以将字符串连接在一起。合并或连接字符串称为串联。请参阅下面的示例：

first_name  =  'Asabeneh' 
last_name  =  'Yetayeh' 
space  =  ' ' 
full_name  =  first_name   +   space  +  last_name 
print ( full_name ) # Asabeneh Yetayeh 
# 使用 len() 内置函数检查字符串的长度
print ( len ( first_name ))   # 8
打印( len ( last_name ))    # 7
打印( len ( first_name ) >  len (last_name )) # 真
打印( len ( full_name )) # 16

4.3字符串中的转义序列

在 Python 和其他编程语言中，\ 后跟一个字符是一个转义序列。让我们看看最常见的转义字符：

1. \n: 换行
2. \t: Tab 表示（8 个空格）
3. \: 反斜杠
4. ‘: 单引号 (’)
5. “：双引号 (”)

现在，让我们通过示例来看看上述转义序列的使用。

print ( '我希望每个人都喜欢 Python 挑战。\n你是吗？' ) # 换行符
print ( 'Days \t Topics \t Exercises' ) # 添加制表符空格或 4 个空格
print ( 'Day 1 \t 3 \ t 5' )
打印( 'Day 2 \t 3 \t 5' )
打印( 'Day 3 \t 3 \t 5' )
打印( 'Day 4 \t 3 \t 5' )
print ( '这是一个反斜杠符号 ( \\ )' ) # 写一个反斜杠
print ( '在每种编程语言中它都以\" Hello, World! \" ' ' ) # 在单引号内写一个双引号

＃输出
我 希望 每 一个 被 欣赏 的 Python的 挑战。
是 你？
Days 	Topics	练习
Day  1 	5 	    5 
Day  2 	6 	    20 
Day  3 	5 	    23 
Day  4 	1 	    35
这 是 一个 反斜杠  符号(\)
在 每种 编程 语言中， 它都 以“Hello, World!”开头 。 

4.4字符串格式化

旧式字符串格式（% 运算符）

在 Python 中有很多格式化字符串的方法。在本节中，我们将介绍其中的一些。“%”运算符用于格式化包含在“元组”（固定大小的列表）中的一组变量，以及一个格式字符串，其中包含普通文本和“参数说明符”，特殊符号如“%s” , “%d”, “%f”, “%.number of numbersf”。

1. %s - 字符串（或任何具有字符串表示的对象，如数字）
2. %d - 整数
3. %f - 浮点数
4. “%.number of digitsf” - 具有固定精度的浮点数

＃字符串只
FIRST_NAME  =  'Asabeneh'
姓氏 =  'Yetayeh'
语言 =  'Python的
formated_string  =  “我是％s％S。我教 %s'  % ( first_name , last_name , language )
打印( formated_string )

# 字符串和数字
radius  =  10 
pi  =  3.14 
area  =  pi  *  radius  **  2 
formated_string  =  '半径为 %d 的圆的面积是 %.2f.'  % ( radius , area ) # 2 指的是点后的 2 个有效数字

python_libraries  = [ 'Django的，'瓶'，'NumPy的'，'Matplotlib' ，'熊猫' ]
 formated_string  =  '以下是Python库：％s'的 ％（python_libraries）
打印（formated_string）＃“下面是Python库:['Django', 'Flask', 'NumPy', 'Matplotlib','Pandas']"

新样式字符串格式 (str.format)

这种格式是在 Python 版本 3 中引入的。

FIRST_NAME  =  'Asabeneh'
姓氏 =  'Yetayeh'
语言 =  'Python的
formated_string  =  “我{} {}。我教 {}'。格式（名字，姓氏，语言）
打印（格式化字符串）
 a  =  4 
b  =  3

打印( '{} + {} = {}' .格式( a , b , a  +  b ))
打印( '{} - {} = {}' .格式( a , b , a  -  b ))
打印( '{} * {} = {}' . format ( a , b , a  *  b ))
 print ( '{} / {} = {:.2f}' . format ( a , b , a /  b )) # 限制为小数点后两位数
print ( '{} % {} = {}' . format ( a , b , a  %  b ))
 print ( '{} // {} = {}' .格式( a , b , a  //  b ))
打印( '{} ** {} = {}' . format ( a , b , a  **  b ))

# 输出
4  +  3  =  7 
4  -  3  =  1 
4  *  3  =  12 
4  /  3  =  1.33 
4  %  3  =  1 
4  //  3  =  1 
4  **  3  =  64

# 字符串和数字
radius  =  10 
pi  =  3.14 
area  =  pi  *  radius  **  2 
formated_string  =  '半径为 {} 的圆的面积是 {:.2f}.' . format ( radius , area ) # 小数点后 2 位
打印( formated_string )

字符串插值 / f-Strings (Python 3.6+)

另一种新的字符串格式是字符串插值，f-strings。字符串以 f 开头，我们可以在相应的位置注入数据。

a  =  4 
b  =  3
打印( f' { a } + { b } = { a  + b } ' )
打印( f' { a } - { b } = { a  -  b } ' )
打印( f' { a } * { b } = { a  *  b } ')
打印( f' { a } / { b } = { a  /  b :.2f } ' )
打印( f' { a } % { b } = { a  %  b } ' )
打印( f' { a } / / { b } = { a  //  b } ' )
打印(f' { a } ** { b } = { a  **  b } ' )

4.4Python 字符串作为字符序列

Python 字符串是字符序列，并与其他 Python 有序对象序列（列表和元组）共享它们的基本访问方法。从字符串（以及任何序列中的单个成员）中提取单个字符的最简单方法是将它们解包到相应的变量中。

拆包字符

language = 'Python'
a,b,c,d,e,f = language # unpacking sequence characters into variables
print(a) # P
print(b) # y
print(c) # t
print(d) # h
print(e) # o
print(f) # n

通过索引访问字符串中的字符

在编程中计数从零开始。因此，字符串的第一个字母的索引为零，字符串的最后一个字母是字符串的长度减一。

language  =  'Python' 
first_letter  =  language [ 0 ]
 print ( first_letter ) # P 
second_letter  =  language [ 1 ]
 print ( second_letter ) # y 
last_index  =  len ( language ) -  1 
last_letter  =  language [ last_index ]
 print ( last_letter ) # n

如果我们想从右端开始，我们可以使用负索引。-1 是最后一个索引。

language  =  'Python' 
last_letter  =  language [ - 1 ]
 print ( last_letter ) # n 
second_last  =  language [ - 2 ]
 print ( second_last ) # o

切片 Python 字符串

在 python 中，我们可以将字符串切片为子字符串。

language  =  'Python' 
first_three  =  language [ 0 : 3 ] # 从零索引开始，最多 3 但不包括 3 
print ( first_three ) #Pyt 
last_three  =  language [ 3 : 6 ]
 print ( last_three ) # hon 
# 另一种方式
last_three  =  language [ - 3 :]
 print ( last_three )    # hon 
last_three  =  language [3 :]
打印( last_three )    # 亲爱的

反转字符串

我们可以轻松地在 python 中反转字符串。

问候 =  '你好，世界！
打印（问候[:: - 1 ]）# !dlroW ,olleH

切片时跳过字符

通过将 step 参数传递给 slice 方法，可以在切片时跳过字符。

language  =  'Python' 
pto  =  language [ 0 : 6 : 2 ] # 
print ( pto ) # Pto

4.5字符串方法

有许多字符串方法允许我们格式化字符串。请参阅以下示例中的一些字符串方法：

• 大写（）：将字符串的第一个字符转换为大写字母

挑战 =  “30DaysOfPython”
打印（挑战。利用（））＃“30DaysOfPython”

• count()：返回字符串中子字符串的出现次数，count(substring, start=…, end=…)。start
  是计数的起始索引，end 是要计数的最后一个索引。

挑战 =  '30DaysOfPython'
打印（挑战。计数（'Y' ））＃3
印刷（挑战。计数（'Y' ，7，14））＃1，
打印（挑战。计数（'日'））# 2`

• Endswith()：检查字符串是否以指定的结尾结尾

挑战 =  '30DaysOfPython'
打印（挑战。的endsWith（'开'））   ＃真
印刷（挑战。的endsWith（'灰'）） ＃假

• expandtabs()：用空格替换制表符，默认制表符大小为 8。它接受制表符大小参数

挑战 ='thirty\tdays\tof\tpython'
打印（挑战。expandtabs（））    ＃“30天”
打印（挑战。expandtabs（10））＃“30天”

• find()：返回子字符串第一次出现的索引，如果没有找到返回-1

挑战 =  '30DaysOfPython'
打印（挑战。找到（'Y' ））   ＃16
打印（挑战。找到（'日'））＃17

• rfind()：返回子串最后一次出现的索引，如果没有找到返回-1

挑战 =  '30DaysOfPython'
打印（挑战。RFIND（'Y' ））   ＃5
打印（挑战。RFIND（'日'））＃1

• format(): 将

first_name  =  'Asabeneh' 
last_name  =  'Yetayeh' 
age  =  250 
job  =  'teacher' 
country  =  'Finland' 
sentence  =  '我是{} {}。我是一个 {}。我已经 {} 岁了。我住在 {}。' . 格式（FIRST_NAME，姓氏，年龄，职业，国家）
打印（句）＃我Asabeneh Yetayeh。我今年 250 岁。我是老师。我住在芬兰。

radius  =  10 
pi  =  3.14 
area  =  pi  *  radius  **  2 
result  =  '半径为 {} 的圆的面积为 {}'。format ( str ( radius ), str ( area ))
 print ( result ) #半径为10的圆的面积是314

• index()：返回子字符串的最低索引，附加参数表示开始和结束索引（默认为 0 和字符串长度 - 1）。如果未找到子字符串，则会引发
  valueError。

挑战 =  '30DaysOfPython' 
SUB_STRING  =  'DA'
打印（挑战。指数（SUB_STRING））   ＃7
打印（挑战。指数（SUB_STRING，9）） ＃错误

• rindex()：返回子串的最高索引，附加参数表示起始和结束索引（默认0和字符串长度-1）

挑战 =  '30DaysOfPython' 
SUB_STRING  =  'DA'
打印（挑战。RINDEX（SUB_STRING））   ＃8
打印（挑战。RINDEX（SUB_STRING，9）） ＃错误

• isalnum()：检查字母数字字符

挑战 =  '30DaysOfPython'
打印（挑战。字符isalnum（）） ＃真

挑战 =  '30DaysPython'
打印（挑战。字符isalnum（）） ＃真

挑战 =  “30DaysOfPython”
打印（挑战。字符isalnum（）） ＃假，空间不是字母数字字符

挑战 =  '30DaysOfPython2019的'
打印（挑战。字符isalnum（）） ＃假

• isalpha()：检查所有字符串元素是否都是字母字符（az 和 AZ）

挑战 =  '30DaysOfPython'
打印（挑战。因而isalpha（）） ＃假，空间被再次排除
挑战 =  'ThirtyDaysPython'
打印（挑战。因而isalpha（）） ＃真
NUM  =  '123'
打印（NUM。因而isalpha（ ))       # 错误

• isdecimal(): 检查字符串中的所有字符是否都是十进制 (0-9)

挑战 =  '30DaysOfPython'
打印（挑战。isdecimal（））  ＃假
的挑战 =  '123'
打印（挑战。isdecimal（））  ＃真
挑战 =  ' \ u00B2 '
打印（挑战。ISDIGIT（））   ＃假
的挑战 =  '12 3'
打印（挑战。isdecimal（））  ＃假，空间不允许

• isdigit()：检查字符串中的所有字符是否都是数字（0-9 和其他一些用于数字的 unicode 字符）

挑战 =  '30DaysOfPython'
打印（挑战。ISDIGIT（）） ＃假
的挑战 =  '30'
打印（挑战。ISDIGIT（））   ＃真
挑战 =  ' \ u00B2 '
打印（挑战。ISDIGIT（））   ＃真

• isnumeric()：检查字符串中的所有字符是否都是数字或数字相关的（就像 isdigit()，只接受更多的符号，比如 ½）

NUM  =  '10'
印刷（NUM。ISNUMERIC（）） ＃真
NUM  =  ' \ u00BD '  ＃½
打印（NUM。ISNUMERIC（）） ＃真
NUM  =  '10 0.5'
打印（NUM。ISNUMERIC（）） ＃假

• isidentifier()：检查一个有效的标识符——它检查一个字符串是否是一个有效的变量名

挑战 =  '30DaysOfPython'
打印（挑战。isIdentifier不同（）） ＃假的，因为它以数字开头的
挑战 =  '30_days_of_python'
打印（挑战。isIdentifier不同（）） ＃真

• islower()：检查字符串中的所有字母字符是否都是小写

挑战 =  “30 days of python”
打印（挑战。islower判断（）） ＃真
挑战 =  “30 days of python”
打印（挑战。islower判断（）） ＃假

• isupper()：检查字符串中的所有字母字符是否都是大写

挑战 =  “30 days of python”
打印（挑战。isupper（）） ＃假
的挑战 =  '30 days of python
打印（挑战。isupper（）） ＃真

• join()：返回一个连接的字符串

web_tech  = [ 'HTML' , 'CSS' , 'JavaScript' , 'React' ]
 result  =  ' '。join ( web_tech )
 print ( result ) # 'HTML CSS JavaScript React'
web_tech  = [ 'HTML' , 'CSS' , 'JavaScript' , 'React' ]
 result  =  '# '。join ( web_tech )
 print ( result ) # 'HTML# CSS# JavaScript# React'

• strip()：从字符串的开头和结尾删除所有给定的字符

Challenge  =  '30 days of python' 
print ( challenge . strip ( 'noth' )) # '三十天的 py'

• replace()：用给定的字符串替换子字符串

挑战 =  “30 days of python”
打印（挑战。替换（“Python”，“编码”））＃“30天编码”

• split()：拆分字符串，使用给定的字符串或空格作为分隔符

挑战 =  “30 days of python”
打印（挑战。分裂（））＃[“30”，“天”，“of”，“Python”]
挑战 =  “30，天，，Python”
打印（挑战。分裂( ', ' )) # ['30', '天', 'of', 'python']

• title()：返回一个标题大小写的字符串

挑战 =  “30 days of python”
打印（挑战。标题（）） ＃Python30天

• swapcase()：将所有大写字符转换为小写，将所有小写字符转换为大写字符

挑战 =  '30 days of python'
打印（挑战。的swapCase（））   # Python30天
挑战 =  '30 days of python'
打印（挑战。的swapCase（））  # Python30天

 - startswith()：检查字符串是否以指定的字符串开头

```python
挑战 =  “30 days of python”
打印（挑战。startswith（“30”）） ＃真

挑战 =   '30 days of python'
打印（挑战。startswith（'30'）） ＃假

🎉 恭喜！ 🎉你是一个非凡的人，你有非凡的潜力。您刚刚完成了第 4 天的学习。

今天分享的字数已经很多了，作为一个续集更新，感兴趣了解下面的学习内容，记得关注我，你们的三连是我持续输出的动力，感谢。