<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0"><channel>
<title>Python - 翔宇亭IT乐园</title>
<link>http://www.biye5u.com</link>
<language>zh-cn</language>
<description>翔宇亭IT乐园</description>
<copyright>http://www.biye5u.com</copyright>
<generator>Rss Generator By NewAsp.Net</generator>
<docs>http://www.biye5u.com/article/rssfeed.asp</docs>
<image>
<title><![CDATA[翔宇亭IT乐园]]></title>
<url>http://www.biye5u.com/images/logo.gif</url>
<link>http://www.biye5u.com</link>
</image>
<item>
<title><![CDATA[Python函数中的*args和**kwargs参数]]></title>
<link>/article/python/2022/6571.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2022-12-14 20:31:44</pubDate>
<description><![CDATA[本站在《Python中自定义函数的方法》一文中讲解了Python中定义一个函数的方法以及基本参数的相关知识。
但在实际应用中，我们在定义一个函数时无法确切的知道一个函数到底需要指定多少个参数，或者一些参数根据实际情况进行指定，而非每次调用时都用的上，这时我们在定义函数时需要借助*args和*kwargs参数来解决这个问题了。
*args参数
*args表示一个列表或元组型的位置参数，用于传递给函数进行处理使用。
当在定义一个函数时，我们无法确定参数的个数时，可以使用*args来传递任意数量的参数。
此时，*用于将参数打包成一个列表或元组传递给函数。当然，参数的名字是任何符合Pytho...]]></description>
</item>
<item>
<title><![CDATA[Python中的类和对象]]></title>
<link>/article/python/2022/6569.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2022-12-14 01:00:32</pubDate>
<description><![CDATA[这篇文章将介绍Python中类和对象的定义和使用方法。
类和对象基础知识
在面向对象世界里，我们在描述事物时一般从静态特征和动态特征两个方面进行描述。比如描述一个人，年龄、发色、脸型、身高等这些属于静态特征，而说话、跑步、走路等，这些属于动态特征。
在实际中，我们到底需要描述事物的那些特征，这跟我们要研究的问题领域有关，比如同样一个人，他作为学生时，我们可能关注他的学号、姓名、年龄、班级、专业、学习年限等静态特征，可能关注他的选课、考试、参加体育活动等动态特征；如果他作为一个职工，可能我们要关注他的职工号、姓名、年龄、工作年数、职级、入职时间等静态特征，可能关注他的晋职、加薪、辞职、退休...]]></description>
</item>
<item>
<title><![CDATA[使用Python处理系统环境变量]]></title>
<link>/article/python/2022/6566.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2022-06-15 11:55:36</pubDate>
<description><![CDATA[环境变量在操作系统中用于指定操作系统运行环境的一些参数。如临时文件夹的位置，某种程序的搜索路径等。
环境变量使用变量名=具体值的方式进行指定，每个变量之间使用分号进行分隔。
Python操作环境变量原理
在Python中，你可以把系统环境变量当做一个字典来操作。环境变量的变量名称即为字典的键（key），而对应的键值就是对应的环境变量的值。
我们可以使用Python中os模块中的environ对系统变量进行相关操作。

Python中读取环境变量的所有值
下面这个例子用于输出所有的系统变量信息
import os

print(os.environ)
输出结果如下：
en...]]></description>
</item>
<item>
<title><![CDATA[Python中的array模块]]></title>
<link>/article/python/2022/6565.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2022-06-09 09:34:33</pubDate>
<description><![CDATA[Python并没有像其他语言那样直接提供了数组(array)这种数据结构，而是通过导入array模块来完成数组的相关操作。
在Python中没有直接引入数组，也是由于Python中提供了列表这种数据结构，支持像数组一样的元素插入、修改和删除等操作。
但Python列表中的元素可以具有不同的数据类型，这一点与数组是不同的。如果想即使如此，额外提供一种数据结构来解决这种问题也没有必要。

一、Python中的array模块
Python中的array模块允许我们创建一个具有数据类型约束的数组，而且Python的array模块仅支持几类数据类型。其支持的数据类型主要有以下几种：

 
...]]></description>
</item>
<item>
<title><![CDATA[Python中取模运算符——%的用法详解]]></title>
<link>/article/python/2022/6563.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2022-05-05 20:31:26</pubDate>
<description><![CDATA[Python中的取模运算符%用于返回两个数相除时的余数部分。
取模运算符%属于算术运算符。

一、语法格式
%运算符的语法格式如下：
res = a % b
这里 的 a 相当于被除数， b 为除数， res 为运算结果，即 a 除以 b 后的余数。
如果 a 和 b 都为整数，则余数也是一个整数。如果 a 和 b 中有一个是浮点数，则运算结果也为浮点数。
二、Python取模运算符示例
下面给出一些具体的例子来了解 % 的使用及输出结果情况。
1. 整数的取模运算
&gt;&gt;&gt; 8 % 3
2
&gt;&gt;&gt; 3 % 3
0
&gt;&gt;&gt;
2. 浮点数的取模运算
&gt;&gt;&gt; 8 %...]]></description>
</item>
<item>
<title><![CDATA[Python中包的创建与使用]]></title>
<link>/article/python/2021/6543.html</link>
<author>biye5u.com</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-10-31 14:28:48</pubDate>
<description><![CDATA[微信搜索本站订阅号：优雅的代码。欢迎关注。

一个实际应用的程序往往有多个模块、文件以及其它资源构成，为了清晰有效的组织这些程序，我们需要包来管理这些资源。Python中也支持包的概念。
Python的包是什么
Python包是存放程序模块和子包的文件夹，是包含若干子包和模块的命名空间。
每个包必须包含一个名为“__init__.py”的特殊文件，这个文件的内容可以为空，也可以包含导入模块的数据或信息。
包内可以存放的资源
如何创建一个包
在Python创建一个包可以分为两步：
（1）创建一个文件夹，并给这个文件夹一个合适的名字，文件夹的名字就是包的名字。
我们可以在操作系...]]></description>
</item>
<item>
<title><![CDATA[Python lambda表达式与匿名函数]]></title>
<link>/article/python/2021/6542.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-10-28 09:20:56</pubDate>
<description><![CDATA[微信搜索本站订阅号：优雅的代码。欢迎关注。

匿名函数是指没有函数名称的函数。而Python中的lambda保留字可以用来定义一个匿名函数。
Python中的lambda可以用于需要函数对象的地方，可以帮助我们快捷的完成一定的运算。在lambda函数中可以传入多个参数，但只允许有一个表达式，该表达式被计算后并返回结果。
lambda函数的语法格式
[fun_obj =] lambda [parameter_list] : expression
位于[ ]中的内容是可选的。
lambda函数示例
下面这个例子用于计算一个数的平方数。
f = lambda x: x*x
s1 ...]]></description>
</item>
<item>
<title><![CDATA[python中的main()函数]]></title>
<link>/article/python/2021/6541.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-10-27 15:34:00</pubDate>
<description><![CDATA[微信搜索本站订阅号：优雅的代码。欢迎关注。

像C语言、C++、C#、Java这种语言，程序总是从main函数开始执行的。但Python程序与这些语言不同，它并不需要特殊的函数入口，而是从程序的第一个语句顺序往下执行。但在Python中，只有当直接执行包含main函数的代码块时，main函数可以得到执行，但当包含main函数的语句块被导入时不会被执行。

为什么Python没有固定的main函数？
Python是一种解释型语言，同JavaScript，VbScript一样是一种脚本语言，其运行过程是从上到下，逐行执行的，代码的开始即程序的起点，这决定了它不必像Java，C#那种编译型...]]></description>
</item>
<item>
<title><![CDATA[Python delattr()方法]]></title>
<link>/article/python/2021/6540.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-10-09 18:10:04</pubDate>
<description><![CDATA[微信搜索本站订阅号：优雅的代码。欢迎关注。

Python delattr()是Python的内置函数，其作用是删除一个对象的指定属性。

语法格式
delattr(object, name)
参数
object：某类的对象；
name：字符串类型，代表对象的一个属性名称。
返回值
该函数没有返回值
 
使用举例
下面使用若干例子来说明delattr()函数的具体使用方法。
class Student:
 id = &#39;001&#39;
 name = &#39;丁涛&#39;
 def __init__(self, id,name,age):
 self.id = id
 sel...]]></description>
</item>
<item>
<title><![CDATA[Python complex()方法]]></title>
<link>/article/python/2021/6539.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-10-03 18:15:30</pubDate>
<description><![CDATA[微信搜索本站订阅号：优雅的代码。欢迎关注。


Python complex()方法用于生成一个复数数字。复数是值如real + imag * 1j的数字形式。
complex()的语法格式
一个复数包含实部和虚部两部分，且是complex类的数据类型。因此，Python中的complex()方法语法格式如下：
class complex([ real[, imag]])
参数
real ：可选参数，用于指定转换的结果的复数实部，该参数可以接收能转换为复数的一个字符串。
imag：可选参数，用于指定转换的结果的复数虚部。
返回值
该方法的返回值是形如 real + ima...]]></description>
</item>
<item>
<title><![CDATA[Python compile()方法]]></title>
<link>/article/python/2021/6538.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-09-27 09:00:18</pubDate>
<description><![CDATA[微信搜索本站订阅号：优雅的代码。欢迎关注。


Python中可以使用compile()方法把源程序编译成代码对象或AST（Abstract Syntax Tree）模块对象。使用compile()方法生成的代码对象可以使用exec()函数或eval()函数执行。
compile()语法格式
官方文档给出的语法格式如下：
compile(source, filename, mode, flags = 0, dont_inherit = False, optimize = -1)
参数
source：必要参数，生成代码对象的源，其可以是一个字符串、字节字符串或AST对象。
fi...]]></description>
</item>
<item>
<title><![CDATA[Python classmethod()方法]]></title>
<link>/article/python/2021/6537.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-08-31 16:13:55</pubDate>
<description><![CDATA[python classmethod()是Python标准库中的一个内置方法。在Python中，有三种类型的方法，分别是：实例方法、类方法和静态方法。
这篇文章首先介绍一下类方法的含义及使用方法。
classmethod()方法是什么
在Python中，类方法是可以使用类名直接调用的方法，类方法可以在类的所有对象中进行共享。classmethod()方法可以把类中的一个方法转化为类方法，但要求类中定义的那个方法的第一个参数是 cls ，当然这只是约定俗成的，使用其他标识符也可以，主要用于隐式的表示类自身，以调用类的属性、方法，以及实例化对象等，这点与实例方法中的 self 参数相似。
...]]></description>
</item>
<item>
<title><![CDATA[Python breakpoint()函数]]></title>
<link>/article/python/2021/6536.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-08-14 10:07:12</pubDate>
<description><![CDATA[breakpoint()是Python3.7中新引入的一个内置函数，其主要作用是在开发Python程序时，在使用breakpoint()函数的地方进入程序调试器，以便跟踪观察程序的运行情况。
概述
调试Python程序是一件令人头疼的事情，在使用Python 3.7之前，开发者为调试程序不得不首先引入pdb包，然后调用pdb.set_trace()函数来跟踪调试程序。但如果你准备使用其它调试器，如web-pdb，你就不得不把与PDB模块有关的代码移除掉，然后添加web_pdb.set_trace()方法。这使得为调试Python程序，不得不花费更大的精力和开销，使得Python程序难以维护...]]></description>
</item>
<item>
<title><![CDATA[Python callable()函数]]></title>
<link>/article/python/2021/6535.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-08-13 08:31:47</pubDate>
<description><![CDATA[callable()函数是Python的一个内置函数。该函数判断一个对象是否可被调用，如果传递给该函数的对象可被调用，则返回True，否则返回False。在实际中，即使该函数返回True，也有可能在调用该对象时会失败，当然，若该函数返回的是False，在调用该对象时绝对不会成功。
在Python类中如果定义了__call__()方法，则该类的实例是可调用的。
通俗地讲，一般情况下用户定义的方法/函数是可以调用的，但类的实例一般不能按照方法/函数的形式来调用，但如果类的内部实现了__call__()方法，则该类的实例可以按照方法/函数的形式来调用。
注意：callable()函数在Pyth...]]></description>
</item>
<item>
<title><![CDATA[Python bin()函数]]></title>
<link>/article/python/2021/6534.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-08-10 10:34:48</pubDate>
<description><![CDATA[bin()是Python的一个内置函数，其作用是返回一个整数的二进制表示形式的字符串。该函数的参数可以是一个十进制的整数，也可以是其它进制的整数。返回的字符串以&#39;0b&#39;开始，表示这是一个二进制形式的字符串。其它非整数类型，如果其实现了__index__()函数，也可以使用该函数。
bin()函数的语法格式
官方文档给出的bin()函数的语法形式如下所示：
bin(x)
参数
x：是一个整数数值，可以是十进制的整数，也可以是其它进制的整数，但不可以是浮点数。该参数也可以是在类内部实现了__index__()函数的对象。
返回值
该函数的返回值是x的一个二进制形式的字符串，该字符串以...]]></description>
</item>
<item>
<title><![CDATA[Python repr()函数]]></title>
<link>/article/python/2021/6533.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-08-09 17:50:16</pubDate>
<description><![CDATA[Python repr()函数是Python的内置函数。该函数的作用是返回一个对象的可打印字符表示的字符串。对于大多数类型，该函数返回的字符串值与传递给eval()函数返回的值相同，其它情况则返回一个包含对象类型名称及附加的对象地址信息，这些内容将会放在一对尖括号内。一个类可以通过定义__repr__()函数，控制着其实例返回的内容。
repr()函数的语法格式
官方文档给出的repr()函数语法格式如下：
repr(object)
参数
该函数有一个参数，可以是任何类型的数据。
返回值
该函数的返回值是一个字符串，对于大多数类型，字符串的内容与参数的内容相同，对于类的实例常常返...]]></description>
</item>
<item>
<title><![CDATA[Python ascii()函数]]></title>
<link>/article/python/2021/6532.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-08-08 19:40:57</pubDate>
<description><![CDATA[微信搜索本站订阅号：优雅的代码。欢迎关注。
ascii()是Python内置的一个函数，其作用是返回一个对象的字符串表示形式，但字符串中只包含ASCII编码的字符，而非ASCII编码的字符将使用以反斜杠“\”形式的转义字符表示。
该函数在内部调用repr()函数来实现的，并在输出前使用转义字符来转义非ASCII字符。
ascii()函数语法格式
官方文档给出的ascii()语法格式如下：
ascii(object)
参数
该函数的参数可以是任何原始数据类型或一个对象。
返回值
该函数的返回值是一个字符串，该字符串中包含了ASCII编码的可打印字符，而非ASCII编码的字符将以...]]></description>
</item>
<item>
<title><![CDATA[Python any()函数]]></title>
<link>/article/python/2021/6531.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-08-07 11:07:52</pubDate>
<description><![CDATA[微信搜索：优雅的代码，关注本站订阅号。
Python中any()函数的作用是检查可迭代对象中的元素是否有真值，如果有真值，any()函数返回True，否则返回False。如果可迭代对象为空，则返回False。
简言之，可迭代对象中只要有一个真值，则any()函数返回True，可迭代对象中的元素全为假或为空时返回False.
该函数等于下面的定义：
def any(iterable):
 for element in iterable:
 if element:
  return True
 return False
any()函数语法格式
官方文档给出的any()函数语法格...]]></description>
</item>
<item>
<title><![CDATA[Python all()函数]]></title>
<link>/article/python/2021/6530.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-08-03 11:09:32</pubDate>
<description><![CDATA[Python all()函数是Python的内置函数之一。
Python all()函数的作用是判断给定的可迭代对象的所有元素是否都为真（或者可迭代对象是否为空），如果是则all()函数返回True，否则返回False。
在前面的文章中关于Python中bool值进行介绍过：在Python中，任何值为0的数字类型、空的字符串、空的列表、空的元组、空的集合等都为False，值为None或False的对象也是False，其它情况都为True.
该函数与any()函数具有相似性，读者可以了解一下any()函数的使用方法。
但该函数对于空的可迭代对象将返回True。
all()函数的语法格式...]]></description>
</item>
<item>
<title><![CDATA[Python id()函数]]></title>
<link>/article/python/2021/6529.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-08-01 00:35:47</pubDate>
<description><![CDATA[Python id()是Python的一个内置函数，其作用是返回一个对象的身份标识。Python中一个对象的标识是一个整数。该整数保证对象在其生命周期中是唯一和固定的。在非覆盖的生命周期中，两个对象可能有相同的id()值，在CPython的底层实现中，id()函数用作获取对象的内存地址。
Python id()语法格式
val = id(object)
参数
object：用于获取标识的对象。
返回值
该函数的返回值是一个整数，是对象的标识。

Python id()函数示例
Python中对象的id对于缓存变量的值是非常有用的，Python使用id()函数检索变量值的机制使...]]></description>
</item>
<item>
<title><![CDATA[Python hash()函数]]></title>
<link>/article/python/2021/6528.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-07-31 09:32:29</pubDate>
<description><![CDATA[Python hash()函数是Python中的一个内建函数，其作用是生成一个对象的hash值，hash值的作用是使用整数来标识一个数据。通常讲，相同的数据具有相同的hash值，即使数据之间具有微小的区别，其hash值也是不同的。Hash值通过hash函数来生成。当然，通过hash函数生成的hash值，可能导致两个对象会生成相同的hash值，这称之为：hash冲突，一个较好的hash函数应该较小概率的产生hash冲突。
Python hash()语法格式
hash(object)
参数
object：要计算其哈希值的数据对象。
返回值
一个数字构成的哈希值。

Python h...]]></description>
</item>
<item>
<title><![CDATA[Python float()函数]]></title>
<link>/article/python/2021/6527.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-07-30 09:29:04</pubDate>
<description><![CDATA[Python float()函数的作用是将参数转换为一个浮点数。其参数可以是一个数字字符串或数字，也可以不带参数而生成一个浮点数0.0。
float()语法格式
官方文档给出的float()函数语法格式如下：
class float([x])
参数
该函数有一个可选参数x，该参数可以是一个可以转换为浮点数的字符串、一个数字。
返回值
该函数返回一个浮点数。

float()使用示例
1、不带参数
f1 = float()
print(f1)
输出结果：
0.0
2、参数是字符串
当float()函数的参数是字符串时，字符串必须是可以转换为浮点数的数字，数字前可以...]]></description>
</item>
<item>
<title><![CDATA[Python enumerate()函数]]></title>
<link>/article/python/2021/6526.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-07-29 09:21:44</pubDate>
<description><![CDATA[enumerate()函数是Python的一个内置函数，其作用是把一个序列的每个值转换成一个二元元组，元组中的第一个元素是索引数字，第二个元素是序列的一个值。
enumerate()语法格式
Python官方网站中给出的enumerate()函数的语法格式如下：
enumerate(iterable, start=0)
参数
该函数有两个参数：
iterable: 指定用于生成枚举的序列、迭代器或其它支持可迭代的对象。
start：可选参数，索引开始的数值，默认为0。
返回值
该函数返回一个枚举对象，每个枚举值是包含索引和值本身的元组。

enumerate()函数示例
...]]></description>
</item>
<item>
<title><![CDATA[Python bytes()函数]]></title>
<link>/article/python/2021/6525.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-07-28 00:25:15</pubDate>
<description><![CDATA[Python bytes()函数返回一个整型数字序列的字节对象，整型数字的取值范围为：0&lt;=x&lt;256.
bytes()函数的语法格式
官方参考文档给出的bytes()函数语法格式如下：
class bytes([source[, encoding[, errors]]])
参数
该函数有三个可选参数：
source 可选参数，用于初始化字节对象；
encoding 可选参数，当source为字符串类型时使用该参数指明编码格式，Python使用str.encode()函数将字符串转换为字节。
errors 当source为字符串类型，并使用encoding指定的编码方式编码失败...]]></description>
</item>
<item>
<title><![CDATA[Python bytearray()函数]]></title>
<link>/article/python/2021/6524.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-07-25 12:40:34</pubDate>
<description><![CDATA[这篇文章将介绍Python的bytearray()函数。bytearray()函数创建一个字节数组并返回bytearray对象。bytearray类是可变的整数序列，因此我们可以改变其元素值，元素的取值范围为： 0 &lt;= x &lt; 256
bytearray()函数语法格式
官方文档给出的语法格式如下：
bytearray([source[, encoding[, errors]]])
参数
source 可选参数，用于初始化bytearray对象的数组元素，其取值可以是字符串、整型数或可迭代类型。
encoding 可选参数，当source是字符串时，用于指定字符串的编码模式。
...]]></description>
</item>
<item>
<title><![CDATA[Python bool()函数]]></title>
<link>/article/python/2021/6523.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-07-25 00:08:02</pubDate>
<description><![CDATA[bool()函数是Python的一个内建函数，其作用是对传递的对象或值参数进行标准的真值检测并返回一个布尔值（True / False）。
bool()的语法格式
bool( [x] )
参数
该函数的参数 x 是一个可选参数，其可以是一个对象、某个具体的值或其它表达式。
返回值
该函数返回值有两个：True 或者 False。当检测为真时返回True，否则返回False.
关于真值检测
在Python中，任何对象都可以进行真值检测，这主要用于 if 或 while 条件中。
如果一个对象中定义了__bool__()函数，其结果依赖于该函数的返回值情况；或者对象中定义了__l...]]></description>
</item>
<item>
<title><![CDATA[Python len()函数获取对象的长度]]></title>
<link>/article/python/2021/6522.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-07-14 10:40:27</pubDate>
<description><![CDATA[在Python中，len()函数用于获取对象的长度，即对象中项（items）的数量。
len()函数操作的对象可以是序列（如字符串，字节，元组，列表或range）,也可以是集合（如字典、集合或不可变集合）。
如果len()函数操作的对象长度超过了 sys.maxsize (Python中整型数据的最大值，在32位平台中，其值通常为： 231 - 1 ，在64位平台中，其值通常为： 263 - 1 ）。
Python len()语法格式
len(s)
参数
该函数的参数s可以是一个序列对象（如字符串、字节(bytes)、元组、列表或range），也可以是一个集合对象（如字典(dict...]]></description>
</item>
<item>
<title><![CDATA[Python zfill()函数]]></title>
<link>/article/python/2021/6521.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-07-13 15:27:16</pubDate>
<description><![CDATA[zfill()函数是Python字符串处理的内置函数之一，其作用是在字符串前端补ASCII编码的 &#39;0&#39; 以使字符串达到指定的宽度，并返回处理后的字符串。如果字符串前端有前缀符号（“+”或“-”），则&#39;0&#39;会填补到符号和字符串之间。如果指定的宽度小于或等于字符串的长度，则该函数会返回原字符串。
zfill()函数语法格式
官方文档中给出的该函数的语法格式如下：
str.zfill(width)
 str 是待处理的字符串。
参数
该函数有一个参数 width ，其用于指定处理后的字符串宽度（长度）。
返回值
该函数的返回值是处理后的字符串。

zfill()函数示例
示例...]]></description>
</item>
<item>
<title><![CDATA[Python translate()函数]]></title>
<link>/article/python/2021/6520.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-07-12 20:25:24</pubDate>
<description><![CDATA[Python str.translate()函数是Python字符串类的内建函数之一，其作用是通过给定的转换表把字符串中包含在转换表中的每个字符用转换表中对应的字符进行替换，并返回一个新字符串。
str.translate()语法格式
官方文档给出的Python 3中的语法格式如下：
str.translate(table)
 str 是需要进行转换的字符串。
参数
该函数的参数table时字符映射表，该映射表是需要通过__getitem__()函数实现了索引的对象，如映射和序列。
映射表table可能由以下几种情形：
映射表能返回一个Unicode序数或字符串用于匹配一个或多...]]></description>
</item>
<item>
<title><![CDATA[Python maketrans()函数]]></title>
<link>/article/python/2021/6519.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-07-12 19:50:52</pubDate>
<description><![CDATA[Python maketrans()是一个静态函数（使用str类型直接调用，而非字符串），其作用是为str.translate()函数提供转换字符映射表。
maketrans()语法格式
官方文档给出的语法格式如下：
static str.maketrans(x[, y[, z]])
参数
该函数有三个参数，其中后两个是可选参数。
（1）该函数只有一个参数 x 时， x 必须是字典类型，以给出转换的映射关系。字典的键取值可以是：对应某个Unicode字符的整型序数，或者字符（长度为1的字符串）；键对应的值取值可以为Unicode字符序数（整型），任意长度的字符串或None。
（2...]]></description>
</item>
<item>
<title><![CDATA[Python rpartition()函数]]></title>
<link>/article/python/2021/6518.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-07-11 09:30:30</pubDate>
<description><![CDATA[Python rpartition()字符串处理函数的作用与partition()函数功能相似，只不过其是从右端开始匹配搜索串。
Python rpartition()函数以搜索字符串最后出现的位置为分割，将源字符串分为三部分，并以元组的形式返回分割后的结果，其中元组中的第一个字符串元素是搜索子串之前的内容，第二个字符串元素是搜索子串本身，第三个字符串元素是搜索子串之后的内容。
rpartition()语法格式
str.rpartition(sep)
str是要被搜索的字符串，该函数将在str中找到sep的位置，并以sep为分割，将str分割为三部分。
参数
sep是一个字符串类型...]]></description>
</item>
<item>
<title><![CDATA[Python rindex()函数]]></title>
<link>/article/python/2021/6517.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-07-08 09:30:52</pubDate>
<description><![CDATA[Python rindex()函数与rfind()函数功能相似，其作用是从字符串查找子串最后一次出现的位置索引。但该函数与rfind函数的区别是：在未找到子串时，rfind()函数返回-1，而rindex()函数将引发ValueError错误。
同时，该函数的功能与index()函数也相似，index()函数默认是从左侧开始搜索子串并返回子串第一次出现的位置索引。
rindex()函数语法格式
官方文档给出的语法格式如下：
str.rindex(sub[, start[, end]])
语法中，str是源字符串，该函数将从 str 中找出子串所在的最高索引值。
参数
sub：是必...]]></description>
</item>
<item>
<title><![CDATA[Python rsplit()函数]]></title>
<link>/article/python/2021/6516.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-07-03 09:43:52</pubDate>
<description><![CDATA[Python rsplit()函数功能与split()函数功能非常相似，只不过rsplit()函数是从字符串的右端开始分割字符串。
Python rsplit()函数使用指定的分隔符对字符串进行分割并返回分割后的字符串列表，如果未指定分隔符时，该函数使用任何空白对字符串进行分割，空白包括空格、制表符（\t）、换行符（\n）等。

rsplit的语法格式
str.rsplit(sep = None, maxsplit = -1)
语法中，str是待分割的字符串；
参数
sep：用于指定分隔符，rsplit()函数将以此分隔符对str进行分割，默认值为None，即按照空白符进行分割。...]]></description>
</item>
<item>
<title><![CDATA[Python int()函数]]></title>
<link>/article/python/2021/6515.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-07-02 20:20:54</pubDate>
<description><![CDATA[int()函数是Python的一个内置函数，其作用是把一个数字或字符串转换成整型数据，或者在没有传递任何参数时返回0.
语法格式
官方文档给出的语法格式如下
class int([x = 0])
class int(x, base = 10)
参数
x：一个数字或字符串，若x不是数字或者指定了参数base时，x必须是一个字符串；
base：数字基于的基，即转换数字的进制。默认为10进制。
返回值
该函数的返回值是一个整型数。

不带参数的输出
如上面所述，该函数没有参数时，返回0值。
a = int()
print(&quot;a=&quot;, a)
print(type(a))
...]]></description>
</item>
<item>
<title><![CDATA[Python chr()函数]]></title>
<link>/article/python/2021/6514.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-06-30 13:15:36</pubDate>
<description><![CDATA[chr()是Python中的一个内建函数，其作用是把一个整数转换成其对应的字符。这可以看做是ord()函数的反向操作。
chr()语法格式
Python chr()函数的语法格式如下：
chr(i)
参数
该函数的参数是一个整数，其取值范围为：0~1,114,111（即十六进制：0x10FFFF）。超出该范围将引发ValueError异常。
返回值
该函数执行完返回整数 i 对应的Unicode字符。

使用举例
下面给出一些具体的例子：
print(chr(49))
print(chr(97), chr(65))
print(chr(165))
print(chr...]]></description>
</item>
<item>
<title><![CDATA[Python ord()函数]]></title>
<link>/article/python/2021/6513.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-06-30 10:44:49</pubDate>
<description><![CDATA[ord()函数也是Python中的内建函数之一，其作用是对传入的单个Unicode字符，返回其对应的Unicode编码码点。
如果Unicode字符集中未定义该字符，将引发TypeError错误。
该函数可以视为chr()函数的反向操作，即ord()函数把字符转换成对应的Unicode码点对应的整数值，而chr()函数是把整型数转换成其对应的Unicode字符。
语法格式
ord(c)
参数
该函数有一个参数c，是长度为1的字符，且必须有一个字符。
返回值
该函数的返回值是该字符对应的ASCII码或Unicode码的十进制形式。

使用举例
print(ord(&#39;a&#39;))...]]></description>
</item>
<item>
<title><![CDATA[Python中divmod()函数的使用方法]]></title>
<link>/article/python/2021/6512.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-06-29 19:46:58</pubDate>
<description><![CDATA[divmod()函数也是Python的内置函数之一，其作用是对传入的两个数值（不能是复数）做除法运算和求余运算。
语法格式
Python中divmod()函数的语法格式如下：
divmod(a, b)
该函数有a, b两个参数，都是数值类型的，包括其它进制的数值，但不能是复数。其中，a是被除数（分子），b是除数（分母）。
该函数的返回值是一个元组，包含a与b两个数的商及其余数。
对于整型参数，其结果相当于(a // b, a % b)；
对于浮点数，其结果是( q, a % b)，q通常是math.floor(a / b)，但也可能比其小1。在任何情况下，q * a + a % ...]]></description>
</item>
<item>
<title><![CDATA[Python中的abs()函数]]></title>
<link>/article/python/2021/6511.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-06-29 14:57:03</pubDate>
<description><![CDATA[Python中的abs()函数是Python的内置函数之一，其主要作用是对传入的参数，返回其的绝对量或绝对值。
一、语法格式
Python abs()函数的语法格式如下：
abs( x )
Python中的abs()函数只有一个参数x，该参数可以是整数，浮点数或复数。
如果传递给x的是整数或浮点数，则返回其绝对值，即不考虑符号时的量；
如果传递给x的是复数，则返回复数的模，即该复数与其共轭复数的乘积的平方根。

二、Python abs()使用举例
1、abs()运用到整数中
x = 5
print(&quot;abs(x)=&quot;, abs(x))
x = -10
print(&quot;...]]></description>
</item>
<item>
<title><![CDATA[Python中实现三元条件运算符的方法]]></title>
<link>/article/python/2021/6510.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-06-28 15:44:59</pubDate>
<description><![CDATA[Python中并不像C#中的条件运算符那样使用简洁的符号来实现三元运算的，而是借助了if-else语句。换句话说，Python其实没有提供真正意义上的三元条件运算符，而是借助了if-else来实现，但其语法格式比if-else分支语句要简洁很多。
在Python2.5中，Python提供了该项功能，官方文档把其称之为条件表达式（conditional expression）。

一、语法格式
其语法格式可以使用下面的形式来描述：
[when_true] if [condition] else [when_false]
在语法中，condition一般是个逻辑表达式或逻辑值。开始执行...]]></description>
</item>
<item>
<title><![CDATA[Python中format_map()函数的使用方法]]></title>
<link>/article/python/2021/6509.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-06-25 13:46:41</pubDate>
<description><![CDATA[Python中format_map(mapping)函数的作用与str.format(**mapping)类似，不过，format_map()函数中的mapping可以直接使用词典，而不必再加“**”来解析词典，在&quot;&#123;&#125;&quot;占位符中可以直接使用键名称，不必使用词典的变量来访问。
Python中的format_map()函数是在3.2版中新增的函数，读者在使用该函数时要注意所使用的Python版本。
关于Python中format()函数的使用方法，读者可以参见以下三篇文章：
（1）Python中使用format()函数格式化字符串
（2）Python中使用format()函数对数字进行格...]]></description>
</item>
<item>
<title><![CDATA[Python中format()函数中的对齐与宽度问题]]></title>
<link>/article/python/2021/6508.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-06-22 06:42:05</pubDate>
<description><![CDATA[本站在前面两篇文章中分别介绍了Python中format()函数格式化字符串的基本用法以及format()函数格式化数字字符串的相关知识。这篇文章将进一步接招format()函数有关设置宽度、填充与字符串对齐方式的有关内容。
format()函数使用的相关文章：
（1）Python中使用format()函数格式化字符串
（2）Python中使用format()函数对数字进行格式化
（3）Python中format()函数中的对齐与宽度问题

1、format()函数的输出宽度设置
format()函数可以指定字符串的输出宽度，其语法格式如下：
 &quot;&#123;:width&#125;&quot;.forma...]]></description>
</item>
<item>
<title><![CDATA[Python中使用format()函数对数字进行格式化]]></title>
<link>/article/python/2021/6507.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-06-13 11:06:55</pubDate>
<description><![CDATA[本站在《Python中使用format()函数格式化字符串》一文中介绍了format()函数的基本用法。在这篇文章中将继续介绍format()函数对数字进行格式化的方法。
关于format()函数的使用，本站共有3篇文章：
（1）Python中使用format()函数格式化字符串
（2）Python中使用format()函数对数字进行格式化
（3）Python中format()函数中的对齐与宽度问题

使用format()函数格式化整型数据
在format()函数中，可以使用不同的字符指示符可以将整型数据转换成不同的形式，如输出其对应的二进制形式、八进制形式等。
Python中...]]></description>
</item>
<item>
<title><![CDATA[Python中使用format()函数格式化字符串]]></title>
<link>/article/python/2021/6505.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-06-06 11:27:12</pubDate>
<description><![CDATA[Python中format()函数的作用是对字符串执行格式化操作。
format()函数的语法格式
format()函数的语法形式如下所示：
str.format(*args, **kwargs)
str是待格式化的字符串，一般这个字符串中应包含一对英文半角的花括号&#123; &#125;，用于指定位置索引、参数名或其它格式符，花括号处的内容将被替换成位置索引或参数名及其它格式符指定的值，这些值来自format()函数的参数指定的值序列。
args参数用于给定值序列，用于替换str中&#123;&#125;里位置索引处的值。
kwargs参数以关键字参数（即keyargs = value）的形式给出格式字符串中的值。
...]]></description>
</item>
<item>
<title><![CDATA[Python字符串右端查找函数rfind()函数的用法]]></title>
<link>/article/python/2021/6504.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-05-29 11:00:41</pubDate>
<description><![CDATA[有时我们需要在一个字符串中查找子串，借助程序提供的相关函数可以方便的实现这一功能。
Python中提供了一系列函数可以实现该功能，如find()函数、index()函数。
但有时，我们可能需要从字符串的后端往前搜索子字符串，这与本站前面介绍的find()和index()函数默认从前端开始搜索不同（当然，这两个函数通过指定负数索引可以实现从后端搜索）。
这篇文章将要介绍一个新的函数rfind()可以实现从字符串后端起查找子字符串的功能。

一、rfind()函数的语法格式
Python中rfind()函数的语法格式如下：
str.rfind(sub[, start[, end]])...]]></description>
</item>
<item>
<title><![CDATA[Python字符串处理函数之isascii()函数的使用]]></title>
<link>/article/python/2021/6503.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-05-28 08:45:08</pubDate>
<description><![CDATA[这篇文章将介绍Python3.7中新增的一个字符串处理函数isascii()函数，从函数名称上也应该可以判断该函数的作用：判断字符串中的每个字符是否都为ASCII字符。
一、isascii()函数简介
isascii()函数是在Python3.7中新增的一个字符串处理函数，也就是说在3.7之前的版本中是无法使用这个函数的。
isascii()函数的语法格式如下：
str.isascii()
语法中str是待判断的字符串或字符串变量。
该函数没有任何参数。
该函数执行时，如果字符串对象str是空字符串或字符串中每个字符都是ASCII编码的字符，则该函数返回True，否则返回Fals...]]></description>
</item>
<item>
<title><![CDATA[Python字符串处理函数之encode()函数的使用方法]]></title>
<link>/article/python/2021/6502.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-05-27 22:10:01</pubDate>
<description><![CDATA[在Python中使用encode()函数运用指定的编码方式对字符串进行编码。
关于编码的有关知识，本站在《Python中的Unicode编码格式》一文中进行了详细介绍，读者可以通过这篇文章了解有关字符串编码的问题。
一、Python中encode()函数简介
在Python中，每个字符串对象都有encode()函数，该函数将按照用户指定的编码方式（如UTF-8，UTF-16等）对字符串对象进行编码，编码后返回字符串的字节（Bytes）对象，如未指定编码格式，该函数默认使用“utf-8”编码方式。
该函数的语法格式如下所示：
str.encode(encoding = &quot;utf-8&quot;,...]]></description>
</item>
<item>
<title><![CDATA[Python中的unicode编码格式]]></title>
<link>/article/python/2021/6501.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-05-26 22:40:28</pubDate>
<description><![CDATA[这篇文章将介绍Unicode编码的相关知识以及Python中Unicode编码的相关内容。
为了讲清楚这个问题，我们从计算机的字节及字符编码开始说起。
1 字节
字节（Byte）是计算机信息技术中用于计量存储容量的一种单位，通常情况下，一个字节等于8位(bit)，1位可以表示为二进制中的0或1。
在很多计算机语言中，字节(Byte)也是一种数据类型，用于存储字符。
在不同的字符编码方式中，一个字符占用的字节数量可能不同。如在ASCII编码方式下，用一个字节来存储1个字符。
一个字节共8位，对应的无符号二进制数可以有256种（即28种）情形（0~255，最大数：28-1），如果用一个...]]></description>
</item>
<item>
<title><![CDATA[Python中使用min()函数求最小值]]></title>
<link>/article/python/2021/6500.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-05-13 00:38:26</pubDate>
<description><![CDATA[Python中min()函数的作用是求一组数据中的最小者，如一组数字的最小值。
一、min()函数的语法格式
Python中min()函数的语法格式与max()函数语法格式相同。一般语法格式如下：
min( iterable, *[,key, default])
参数的含义如下：

 iterable 要在该参数所指定的对象中找出最小值，该参数应是一个可迭代的对象，如列表，元组，字符串等。
 key 用于指定排序函数，该函数应只有一行；
 default 当传递的iterable是一个空对象时的默认值。

如果直接将多个数值直接作为参数，其语法格式如下：
min(arg1...]]></description>
</item>
<item>
<title><![CDATA[Python中使用max()函数求一组数据的最大值]]></title>
<link>/article/python/2021/6499.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-05-04 13:43:40</pubDate>
<description><![CDATA[在Python中可以使用max()函数求一组数据的最大值。
一、max()函数语法格式
max()函数的语法格式与min()函数相同，其基本语法格式如下：
max( iterable, *[,key, default])
参数的含义如下：

 iterable 要在该参数所指定的对象中找出最大值，该参数应是一个可迭代的对象，如列表，元组等。
 key 用于指定参数的单行排序函数；
 default 当传递的iterable是一个空对象时的默认值。

如果传递的是多个数值作为参数，其语法形式如下：
max(arg1, arg2, *args[,key])

 arg1,...]]></description>
</item>
<item>
<title><![CDATA[Python中switch语句的替代方法]]></title>
<link>/article/python/2021/6498.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-05-01 12:01:37</pubDate>
<description><![CDATA[在Python中，没有提供与Java、C#等语言中类似的switch语句，其主要原因是switch语句不会提供更有价值的功能。在实际中，我们可以根据实际情况灵活运用其它方法来解决该问题。
本文给出两种替代方法。
一、使用if...else语句来实现相关功能
下面这个例子是根据用户选择的不同运算方式对两个整数执行对应的运算。
v1 = input(&quot;请输入第1个数：&quot;)
v2 = input(&quot;请输入第2个数：&quot;)

x = int(v1)
y = int(v2)

print(&quot;请选择操作：\n 1-加法(+)\n 2-减法(-)\n 3-乘法(×)\n 4-除法(&di...]]></description>
</item>
<item>
<title><![CDATA[Python名称空间与变量作用域]]></title>
<link>/article/python/2021/6497.html</link>
<author>biye5u.com</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-05-01 06:13:18</pubDate>
<description><![CDATA[在Python中，我们可能在不同区域定义了相同名称（如函数名称、变量名称等）的对象，那么，在Python中按照什么规则来访问这些变量呢？本文将对这一问题进行详细的探讨。
一、Python中的名称空间
在Python中，名称空间可以分为4种类型：
（1）局部名称空间(Local Namespace)： 在Python中，位于函数内部、for循环、try-except块是常见的局部名称空间的例子。当函数或对应的代码块执行完毕时，局部名称空间中的对象将被删除。
（2）包裹的名称空间(Enclosed Namespace)： 当一个函数定义在另外一个函数内部时，前者就定义了一个包裹的名称空间，...]]></description>
</item>
<item>
<title><![CDATA[Python中的异常处理]]></title>
<link>/article/python/2021/6495.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-04-24 21:18:48</pubDate>
<description><![CDATA[一个程序即使语法正确，也可能在执行过程中会产生错误，这些错误往往会导致程序非预期提前终止。
在程序执行中遇到的错误，我们称之为异常（Exception）。
在程序中对异常进行处理可以提高用户的体验。
在Python中也提供了类似Java、C#等异常处理方法。
一、Python异常处理简介
Python使用try, except 和 finally三个关键字来处理异常，在异常处理形式上与其它语言相同，但语法使用的关键字稍有不同。
把可能出现异常的语句放在try语句块中，而异常的捕获与处理过程放在 except 语句块中。
在一次异常处理中可以包含多个except语句块，以便用于捕获...]]></description>
</item>
<item>
<title><![CDATA[Python中使用input函数让用户从键盘中输入数据]]></title>
<link>/article/python/2021/6494.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-04-19 16:08:19</pubDate>
<description><![CDATA[input()函数是Python提供的一个内置函数，用于读取用户从键盘中输入的数据。
input()函数从键盘中读取的数据是字符串的形式，在使用过程中可以用变量来接收它，根据实际使用目的，可以使用类型转换函数将其转换成对应的数据类型。
当程序运行到input()函数时，会等待用户输入相关的数据，用户输入完并按下回车键后，input()函数才会读取用户输入的数据。 
在input函数执行过程中，如果遇到EOF则会产生一个EOFError异常，程序终止运行。
一、基本语法
input()函数的语法如下：
input([prompt])
prompt是一个可选参数，该参数是在用户输入数...]]></description>
</item>
<item>
<title><![CDATA[Python中使用递归函数]]></title>
<link>/article/python/2021/6492.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-04-11 17:42:03</pubDate>
<description><![CDATA[在一个函数定义中，自己调用自己的编程方法称之为递归（Recursion）。
一、递归简介
一般来说，递归需要有递归前进阶段、递归边界条件和递归返回阶段。当递归条件不满足时，递归前推；当递归条件满足时，递归返回。
如我们要求5的阶乘（5!），则：
5! = 5 × 4!
我们需要求出4的阶乘后再乘以5就行了，而要求4!：
4! = 4 × 3!
我们需要进一步求出3的阶乘，而
3! = 3 × 2!
我们需要进一步求出2的阶乘，而
2! = 2 × 1!
这时我们知道1的阶乘是1。以上这些步骤就是递归的“前推”过程。
在求出1的阶乘后，我们就知道
2! = 2 ...]]></description>
</item>
<item>
<title><![CDATA[Python中continue语句的使用]]></title>
<link>/article/python/2021/6491.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-04-10 16:41:47</pubDate>
<description><![CDATA[continue语句是Python中的一个保留关键字，用于循环体中结束某一次循环。
一、continue语句的用法简介
Python中的continue语句用于循环中忽略当前的一次循环，在满足循环条件时，还会进行下一次循环。
一般情况下，continue语句用于在for循环或while循环中，配合if语句来决定是否忽略当前的循环。
Python中的continue语句与break语句一样不能用于循环语句以外的地方，否则会给出：“SyntaxError: ‘continue’ outside loop”的错误。
当continue语句用于嵌套循环时，只会忽略一次直接包含continue...]]></description>
</item>
<item>
<title><![CDATA[Python中的break语句]]></title>
<link>/article/python/2021/6489.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-04-07 06:36:39</pubDate>
<description><![CDATA[一、break用法简介
python中的break语句与其它语言中的break语句作用相同，用于循环中跳出循环。
python的break语句不能用于除循环外的其它场合，否则会给出“SyntaxError: ‘break’ outside loop.” 的错误。
python不支持标签(Label)循环，以免给程序带来不必要的复杂性。
其流程图如下：

 二、break语句用于while循环中
i = 0

while i &lt; 5:
 print(i)
 if i == 3:
 break
 i += 1
输出结果：
0
1
2
3
本例中，使用while...]]></description>
</item>
<item>
<title><![CDATA[Python中的return语句]]></title>
<link>/article/python/2020/6488.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2021-02-17 12:45:52</pubDate>
<description><![CDATA[Python中的return语句仅用于函数中以在函数体中带出值。在Python中可以认为所有的函数都有返回值，即使没有return语句或一个没有返回值的return语句也会返回 None.
1、return语句的基本用法
def add(x, y):
 sum = x + y
 return sum
上面函数的作用是计算两个数的和，使用方法如下：
z = add(10, 20)
print(z)
执行情况如下图所示：

上面的函数也可以优化成如下情形：
def add(x, y):
 return x + y
2、不含return语句的输出情况
def donoth...]]></description>
</item>
<item>
<title><![CDATA[Python中ljust和rjust方法的使用]]></title>
<link>/article/python/2020/6487.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-19 07:20:10</pubDate>
<description><![CDATA[Python中的ljust()和rjust()方法属于字符串格式控制方面的函数。这两个方法按照指定的字符串宽度和特定字符来调整字符串宽度，若字符串不足指定的宽度就用指定的字符来填充剩余的宽度。
一、ljust()和rjust()语法格式

str.ljust(width [, fillchar] )
str.rjust(width [, fillchar] )
上面中str即为要操作的字符串；
width 是指定的宽度，若 width 小于或等于原字符串的宽度，则原样返回原字符串；
fillchar是可选参数，即要填充的字符，默认为ASCII空格，即相当于按下键盘中的空格键产生的...]]></description>
</item>
<item>
<title><![CDATA[Python中join()方法的用法]]></title>
<link>/article/python/2020/6485.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-17 23:21:32</pubDate>
<description><![CDATA[Python中join()方法的主要作用是以特定的字符或字符串作为分隔符（字符串）将若干字符串拼接在一起。其作用的对象可以是单独的一个字符串，也可以是一个字符串元组，字符串列表、字符串集合或字符串字典类型。
一、join方法的语法格式
separator-string.join(iterable-string)
iterable-string：待连接在一起的字符串或字符串序列对象（如元组、集合或列表等）；
separator-string：用于连接时使用的字符或字符串。
该函数执行完后将生成一个新字符串。
二、字符串类型示例
&gt;&gt;&gt; str1 = &quot;翔宇亭IT乐园&quot;
&gt;&gt;&gt; s...]]></description>
</item>
<item>
<title><![CDATA[Python中pass语句的作用]]></title>
<link>/article/python/2020/6484.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-16 12:49:49</pubDate>
<description><![CDATA[Python中pass语句实际上一种不会产生任何操作的语句。主要用于创建空的代码块或空函数。
1、用于创建空的代码块
下面程序用于找出20以内所有能被3整除的整数。
list1 = []
for i in range(1, 21):
 if i % 3 != 0:
 pass
 else:
 list1.append(i)
print(list1)
不过上面这个例子仅用于说明pass的用法，实际上完全没必要，使用下面的程序使程序更加简洁：
list1 = []
for i in range(1, 21)
 if i % 3 == 0:
 list1.append(i...]]></description>
</item>
<item>
<title><![CDATA[Python中自定义函数的方法]]></title>
<link>/article/python/2020/6483.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-15 16:46:10</pubDate>
<description><![CDATA[在程序设计中，函数或类的方法可以实现代码的复用，方便代码的维护和实现模块化编程。
Python中在各个模块中内置了大量的函数可以帮助我们实现很多工作。在实际程序设计中，我们也可以把多次重用的代码以函数的方式在程序多个地方进行调用。这就需要程序提供一种自定义函数的功能。
一、Python中自定义函数的语法
在Python中使用 def 关键字来定义一个函数：
def 函数名称(参数列表):
 函数语句
即一个python函数使用def 来定义，后面紧跟函数的名称。函数的参数放在英文半角的小括号中，Python函数可以有参数，也可以没有参数。在函数体中可以有1到多条语句，但Python...]]></description>
</item>
<item>
<title><![CDATA[Python中的for循环语句]]></title>
<link>/article/python/2020/6481.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-13 21:18:06</pubDate>
<description><![CDATA[几乎所有的语言中都有for循环。Python中的for循环与其它语言稍微有些不同，其主要用于循环迭代序列数据，如列表、元组、字符串等。
一、Python中for循环的语法结构
Python中的for循环语法结构相对简单，其形式如下：
for 迭代变量 in 序列名称:
 循环体语句1
 ......
 循环体语句n
二、Python for循环举例
1、for循环用于字符串迭代中
使用for循环可以迭代字符串中的每个字符。
s = &quot;翔宇亭IT乐园&quot;
for c in s:
 print(c)
输出结果：
翔
宇
亭
I
T
乐
园
这个例子简单的迭代...]]></description>
</item>
<item>
<title><![CDATA[Python中的字典类型：创建、访问、修改、删除与相关函数]]></title>
<link>/article/python/2020/6480.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-12 12:35:49</pubDate>
<description><![CDATA[Python中的字典类型是有键值对（key:value）构成的一种类型。Python字典可以存储任何数据类型的数据。
一、Python字典概述
（1）Python字典是一种键-值对数据类型，一旦定义，其键不可以修改，但值可以修改；
（2）Python字典中的键是唯一的，即一个字典中不允许有相同的键；
（3）Python字典是一种无序的键-值集合，即像集合那样，不能使用位置索引来访问或修改字典中的键-值；
（4）Python字典的键值放在一对花括号&#123;&#125;中，每个键值使用英文半角的逗号进行分隔；
（5）既然Python字典的键是不可变的，那么就可以使用字符串、数字、元组来作为字典的键；
...]]></description>
</item>
<item>
<title><![CDATA[Python中的集合操作与集合运算]]></title>
<link>/article/python/2020/6479.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-11 20:16:48</pubDate>
<description><![CDATA[Python中的集合是一种无序的，无重复值的数据结构类型。Python中的集合可以用来检测元素检测或消除重复的元素。
一、python 集合概述
（1）Python中的集合元素是无序的，即元素没有顺序问题，也不能像数组、列表、字符串那样使用索引来访问某个元素；
（2）各元素的顺序也并不是定义时的顺序；
（3）Python中集合的每个元素都是不同的，即使你定义了相同的元素，其在使用时也会自动消除，利用集合这一特点可以去除重复值；
（4）Python中的集合使用&#123;&#125;或set()来定义；
（5）如果定义一个空集只能使用set()来定义，不能使用&#123;&#125;定义，原因是&#123;&#125;用于定义词典的空值；
...]]></description>
</item>
<item>
<title><![CDATA[Python中的range函数]]></title>
<link>/article/python/2020/6478.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-11 08:07:47</pubDate>
<description><![CDATA[python中的range用于生成一个整数序列。range()方法被广泛运用在for循环中遍历或迭代序列数据。
一、range()的语法格式
range()方法通常有两种使用格式：
range(stop)
range( start, stop[, step])

 start：所生成序列的开始数字，在未指定时，默认为0.
 stop：所生成序列的停止数字，该数字不会包含在所生成的序列中；
 step：可选参数，用于指定生成序列的步，默认为1。

该方法可以理解为按照step给定的数生成一个等差数列，两数之差为 step 。
三个参数都必须为整型数。
我们可以使用rang...]]></description>
</item>
<item>
<title><![CDATA[Python Tuple数据类型的定义与使用]]></title>
<link>/article/python/2020/6477.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-10 12:35:26</pubDate>
<description><![CDATA[Python中的元组(tuple)属于不可变数据类型，即定义后不能修改，包括新增元素，删除元素或修改元素的值。
一、tuple数据的定义
tuple中的每一项使用英文半角的逗号进行分隔，并且所有元素值放在一对英文半角的圆括号中“()”，tuple中每一项的数据类型可以不同。
&gt;&gt;&gt; t1 = (1, 2, 3, 1)
&gt;&gt;&gt; print(t1)
(1, 2, 3, 1)
&gt;&gt;&gt; 
从上面的例子中，我们还可以知道，tuple中的元素值可以相同，如上面的例子 t1中有两个 1.
tuple类型也可以像下面这种方式进行定义：
&gt;&gt;&gt; t2 = 1, 2, 3, None, &quot;Pyt...]]></description>
</item>
<item>
<title><![CDATA[Python istitle()函数的使用方法]]></title>
<link>/article/python/2020/6476.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-08 13:48:47</pubDate>
<description><![CDATA[Python中提供了大量的内建字符串函数可以帮助我们解决很多实际问题。Python string istitle()函数也是字符串处理的内建函数之一。
Python istitle()函数的作用是检查一个字符串中的每个单词开头字母是否为大写，而其它字符都为小写形式，如果是这样则返回True，否则返回 False。
一、istitle()函数的语法格式
str.istitle()
该函数没有参数，str是待检查的字符串或字符串变量。
该函数的返回值有两个：
True ：当字符串中每个单词的首字母为大写，而其余字符是小写形式时返回True。
False：当不满足上面条件时则返回Fal...]]></description>
</item>
<item>
<title><![CDATA[Python中创建列表、访问列表、删除列表等操作方法]]></title>
<link>/article/python/2020/6475.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-08 06:54:49</pubDate>
<description><![CDATA[Python列表是Python中很重要的一个数据类型。列表中的每个数据称之为列表的项。列表中的每一项使用英文逗号进行分隔，所有项放在方括号中。同时，列表中的每项的数据类型不一定相同。我们可以对列表项进行增，改，删操作。
一、列表的创建
lst1 = [] #创建一个空的列表
lst2 = [&#39;Python&#39;, &#39;Java&#39;, &#39;R&#39;, &#39;SPSS&#39;] # 字符串列表
lst3 = [1, 2, 3, 4, 5] # 整型列表
lst4 = [1, &#39;Python&#39;, 2, &#39;Java&#39;, &#39;R&#39;, 3] # 混合数据类型的列表

# 使用print方法输出列表
print(ls...]]></description>
</item>
<item>
<title><![CDATA[Python isprintable()函数检测字符串中的每个字符是否都为可打印字符]]></title>
<link>/article/python/2020/6474.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-07 12:49:51</pubDate>
<description><![CDATA[Python字符串处理函数isprintable()的作用是检测字符串中的所有字符是否都为可打印字符，如果字符串中的每个字符都为可打印字符或字符串为空的话，就会返回 True ，否则返回 False 。
一、isprintable()语法格式
string_object.isprintable()
该函数没有参数，string_object 是要进行检测的字符串或字符串变量。
该函数的返回值为逻辑值：True 或 False .
二、什么是可打印字符
要知道这个问题，我们只需要弄清楚哪些字符属于非可打印字符即可。
根据官方文档描述（str.isprintable()），非可打印字...]]></description>
</item>
<item>
<title><![CDATA[Python逻辑推理：三对情侣到底谁和谁结婚]]></title>
<link>/article/python/2020/6473.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-06 20:13:39</pubDate>
<description><![CDATA[今天分享并实现一下 @潘石屹 （微博地址：http://blog.sina.com.cn/panshiyi）微博中的题目（#潘石屹用Python解决100个问题#）。
一、题目描述
有3对情侣结婚，假设3个新郎为A、B、C，3个新娘为X、Y、Z。有参加婚礼的人搞不清谁和谁结婚，所以去询问了这6位新人中的3位，得到的回答如下：新郎A说他要和新娘X结婚；新娘X说她的未婚夫是新郎C；而新郎C说他要和新娘Z结婚。听到这样的回答后，提问者以为他们都是在开玩笑，说的都是假话，并且他仍搞不清谁和谁结婚。现在请试着用Python语言编程，推导出到底哪位新郎和哪位新娘结婚？#潘石屹用Python解决100个...]]></description>
</item>
<item>
<title><![CDATA[全面掌握Python字符串切片方法]]></title>
<link>/article/python/2020/6472.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-06 07:11:30</pubDate>
<description><![CDATA[在《Python字符串的索引与访问字符串中的字符》文章中介绍了使用字符串位置索引可以访问字符串中的单个字符的方法，但有时，我们需要访问字符串中的若干个连续的字符，即使用字符串中的一个子串。Python针对这种情况也提供了比较方便的处理方式。 简单说，Python字符串切片就是按照指定索引截取字符串中的片段构成一个新的字符串。 一、语法结构 str_object[start_pos : end_pos : step] 切片从 start_pos 开始（包含起始位置索引处的字符），结束于 end_pos（不包含结束位置索引处的字符）； step 表示步长，即每step个字符截取1次字符； Pyth...]]></description>
</item>
<item>
<title><![CDATA[使用Python求指数为20以内的所有梅森素数]]></title>
<link>/article/python/2020/6471.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-05 19:54:32</pubDate>
<description><![CDATA[这篇文章将要介绍梅森素数的定义以及在Python中实现的方法。
一、梅森素数
梅森数（Mn）指的是形如2n - 1的正整数，其中指数 n 是素数。
如果一个梅森数是素数，则称其为梅森素数。例如22-1=3、23-1=7都是梅森素数。
当n=2，3，5，7时，Mn都是素数，但n = 11时，Mn = M11 = 211 - 1 = 2047 = 23 × 89，显然 M11 不是梅森素数。
目前仅发现 51 个梅森素数，最大的是 M82589933 （即2的82589933次方减1），有24862048位。
梅森素数历来都是数论研究中的一项重要内容，也是当今科学探索中的热点和难点问...]]></description>
</item>
<item>
<title><![CDATA[Python使用while循环输出斐波那契数列(Fibonacci)]]></title>
<link>/article/python/2020/6470.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-05 08:30:47</pubDate>
<description><![CDATA[斐波那契数列又称费波那契数列（意大利语：Successione di Fibonacci），又译为费波拿契数、斐波那契数列、费氏数列、黄金分割数列。在西方，首先研究这个数列的是比萨的列奥那多（意大利人斐波那契Leonardo Fibonacci（1175-1250））,斐波那契在1202年著的《计算之书》中描述了该数列。（百度百科）
一、斐波那契数列定义
在数学上，以递归的形式来定义这个数列。

F0 = 0
F1 = 1
Fn = Fn-1 + Fn-2 (n&ge;2)
也就是说，该数列的第0项是0，第1项是1，从第2项开始，每项都是前两项的和。
很多教科书中在描述该问题时...]]></description>
</item>
<item>
<title><![CDATA[Python中的原生字符串:r字符的作用]]></title>
<link>/article/python/2020/6469.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-04 12:53:21</pubDate>
<description><![CDATA[Python中的转义字符可以帮助我们在字符串处理中提供特殊的需求，如换行、使用制表键、使用特殊符号等。但有时，我们需要把字符串的内容原样输出来，这时就需要特殊的处理方式了。
在Python字符串前使用字符 &#39;r&#39; 或 ‘R’ 可以实现这个需求，如：
str = r&#39;Python\nJava&#39;
像这种在字符串前端使用了 &#39;r&#39; 或 &#39;R&#39; 的字符串叫原生字符串。
原生字符串中的每个字符都表示它本身的含义。
如果读者对于Python中的转义字符不是很了解的话，可以看一下本站中的《Python中的转义字符》这篇文章。

下面使用几个例子来说明一下具体使用方法：
&gt;&gt;&gt; s1=&quot;Pyt...]]></description>
</item>
<item>
<title><![CDATA[Python isidentifier()判断是否为Python的合法标识符]]></title>
<link>/article/python/2020/6468.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-04 12:30:26</pubDate>
<description><![CDATA[Python中isidentifier()函数的作用是检查一个字符串是否是Python有效的标识符。
一、标识符命名规则
标识符是用来定义Python中的变量、类、函数名称、模块名称以及Python中的保留字。标识符命名时应遵循一定的规则，否则导致语法错误。Python中合法的标识符应满足以下规则：
（1）标识符只能由下划线或字母开始，不能是数字；
（2）标识符中不能含除下划线之外的其它特殊字符，如&#36;,#,%,~等；
（3）在定义自己的标识符时，不能使用Python的保留字。
（4）Python中理论上可以使用Unicode中除特殊字符、格式控制符、不可打印字符、符号字符、空白符之...]]></description>
</item>
<item>
<title><![CDATA[Python while循环]]></title>
<link>/article/python/2020/6466.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-03 07:05:35</pubDate>
<description><![CDATA[Python while循环是在满足一定条件时反复执行某一语句块，直到条件值为假为止。
一、while循环语法结构
while 循环条件:
 # 循环体语句
二、while循环流程图

程序执行到while循环时：
（1）先判断条件是否为True；
（2）如果为True，则执行循环体中的语句；
（3）如果为False，则执行循环体后边的其它语句；
（4）执行完一次循环体后，再次判断条件，进入（2）。
三、while循环使用示例
1、使用while循环计算1~100所有数字的和。
i = 1
sum = 0
while i &lt;= 100:
 sum += i
 ...]]></description>
</item>
<item>
<title><![CDATA[Python的分支语句：if...elif...else]]></title>
<link>/article/python/2020/6465.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-03 06:08:00</pubDate>
<description><![CDATA[ Python中的 if...elif...else 语句属于程序流程控制的语句，用于条件判断中，根据不同的条件进入到不同的语句块进行执行。Python中的分支结构只有这一种，不像C#，Java等语言中还有switch语句。if，elif 和 else 是Python的关键字，不能用于定义其它标识符。

一、语法结构
Python中标准的if-else语句语法结构如下：
if 条件1:
 # 语句块1
elif 条件2:
 # 语句块2
... # 可以有多个elif
else:
 # else语句块
要注意：
（1）Python是使用缩进来表示代码层级结构的，不能使用...]]></description>
</item>
<item>
<title><![CDATA[Python expandtabs()函数的使用]]></title>
<link>/article/python/2020/6464.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-07-02 05:50:09</pubDate>
<description><![CDATA[Python中expandtabs()函数的作用是允许用户自定义（扩展）字符串中 &#39;\t&#39; 字符输出的空格数量。在Python中TAB制表键字符输出的空格数量默认为8。该函数在处理输出的空格数量时会把tab字符前边的字符数考虑进去。也就是说实际输出的空格数量是给定的tab的尺寸减去tab键前面的字符数量。
一、expandtabs()函数的语法格式
str.expandtabs(tabsize = 8)
str：待处理的字符串
参数：tabsize，指定tab的尺寸，默认为8个空白字符。
返回值：返回处理后的字符串。
二、expandtabs()函数使用示例
1、参数使用默认值
...]]></description>
</item>
<item>
<title><![CDATA[Python字符串的索引与访问字符串中的字符]]></title>
<link>/article/python/2020/6462.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-30 07:14:26</pubDate>
<description><![CDATA[字符串是Python中一种非常重要的数据类型。Python字符串是字符的集合，是由单引号、双引号或三引号包裹起来的若干字符的序列。Python字符串中的每个字符使用ASCII或Unicode字符编码，可以认为Python字符串是Unicode字符的集合。在前面的教程中，本站 已介绍了Python字符串的定义方法：《Python中的字符串String》。这篇文章将重点介绍Python字符串字符索引的方法及使用索引访问字符串中的字符。
Python字符串索引方法
与其它语言一样，Python字符串的索引也是从0开始的，下面给出一个字符串“翔宇亭IT乐园”的索引方式：

 Python中字符...]]></description>
</item>
<item>
<title><![CDATA[Python title()字符串处理函数的使用]]></title>
<link>/article/python/2020/6461.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-29 12:51:57</pubDate>
<description><![CDATA[Python中字符串处理函数 title() 函数的作用是把字符串中每个单词的首字母变成大写形式，其余字母变成小写形式。
title()函数的语法格式
str.title()
str：是待处理的字符串或字符串变量；
参数：该函数没有参数；
返回值：该函数返回处理后的字符串，该函数不会影响原字符串的内容和形式。
title()函数使用示例
1、使用示例1
str1 = &quot;python is simple&quot;
print(str1.title()) # Python Is Simple
str1 = &quot;Python is SIMPLE&quot;
print(str1.title()) ...]]></description>
</item>
<item>
<title><![CDATA[Python index()函数在字符串处理中的使用]]></title>
<link>/article/python/2020/6460.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-29 12:25:44</pubDate>
<description><![CDATA[Python提供了大量的字符串处理函数，可以帮助我们完成很多有意义的工作。
这里介绍的 index() 函数也是一个Python内建的字符串处理函数，它的作用是返回子字符串在原字符串中首次出现的位置索引。
index()函数的语法格式
str.index( sub [, start [, end ]])
str：是要进行处理的字符串或字符串变量；
各参数的含义如下：

 sub：要查找的子字符串；
 start：可选参数，在 str 中开始查找的起始位置索引，默认为0；
 end：可选参数，在 str 中查找时停止搜索的位置索引，默认为字符串的长度；

index()函数...]]></description>
</item>
<item>
<title><![CDATA[Python中删除字符串尾部空格的函数：rstrip()]]></title>
<link>/article/python/2020/6459.html</link>
<author>biye5u.com</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-29 06:01:45</pubDate>
<description><![CDATA[Python中可以使用 rstrip() 函数来删除一个字符串尾部的空白字符或其它指定的字符。
rstrip()的语法格式
str.rstrip([chars])
str：需要处理的字符串或字符串变量；
参数：参数chars是可选的，在未指定该参数时，默认删除字符串尾部的空白字符；
返回值：该函数执行完后返回处理后的字符串。
rstrip()函数使用示例
1、不带参数的情况
&gt;&gt;&gt; str1 = &quot; 翔宇亭IT乐园 &quot; # 字符串前后端各有两个空格&gt;&gt;&gt; str1.rstrip()&#39; 翔宇亭IT乐园&#39;&gt;&gt;&gt; str2 = &quot;\n \t\r翔宇亭IT乐园\n \t\r&quot; # 字符...]]></description>
</item>
<item>
<title><![CDATA[Python中去除字符串前边空格的函数:lstrip()]]></title>
<link>/article/python/2020/6458.html</link>
<author>biye5u.com</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-29 05:40:24</pubDate>
<description><![CDATA[Python字符串处理函数lstrip()的作用是去除字符串前导空格或指定的前导字符。
语法格式
str.lstrip([chars])
str：待处理的字符串或字符串变量；
参数：参数 chars 是可选的，默认是删除字符串的前导空白字符。
返回值：返回处理后的字符串，该函数不会影响原字符串的内容和格式。
lstrip()函数使用示例
1、不带参数
&gt;&gt;&gt; str1 = &quot; Python is Good &quot; #前后各两个空白&gt;&gt;&gt; str1.lstrip()&#39;Python is Good &#39;&gt;&gt;&gt; &quot;\n\tPython is Good \t&quot;.lstrip() #前后有控制...]]></description>
</item>
<item>
<title><![CDATA[Python swapcase()-字符串大小写翻转函数]]></title>
<link>/article/python/2020/6457.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-28 06:38:37</pubDate>
<description><![CDATA[Python中 swapcase()函数的作用是把一个字符串中的字母大小写形式进行翻转。即该函数会把字符串中原来所有的大写形式的字母字符变成小写形式，而所有的小写形式的字母字符变成大写形式，并返回一个新的字符串。该函数不会影响原字符串的内容和形式。
一、swapcase()函数的语法格式
str.swapcase()
str：str是给定的要进行大小写翻转的字符串或字符串变量。
参数：该函数没有参数
返回值：该函数返回一个字符串，是函数执行后的结果字符串。
说明：该函数不会影响原字符串的内容与形式，而是返回一个新的字符串。
二、swapcase()函数使用示例
1、一些基本使用...]]></description>
</item>
<item>
<title><![CDATA[Python中去除字符串首尾特定字符的函数：strip()]]></title>
<link>/article/python/2020/6455.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-27 06:32:11</pubDate>
<description><![CDATA[Python中strip()函数的作用是去除一个字符串前导和尾部的特定字符，并返回结果字符串。
Python中strip()函数默认是删除字符串前导和尾部空格，通过设定参数，也可以去除字符串前导和尾部的其它特定字符。
strip()函数的语法格式
str.strip( [ chars ] )
语法中的 str 即要被操作的字符串或字符串变量；
该函数有一个参数 chars ，是可选参数，用于指定从字符串前导或尾部要删除的字符，默认为空白。
该函数执行完后返回操作结果字符串。
stip()函数使用示例
1、没有参数的情况
strip()函数在没有参数时默认移除的是字符串的前导和...]]></description>
</item>
<item>
<title><![CDATA[Python splitlines()函数的使用方法]]></title>
<link>/article/python/2020/6454.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-26 18:32:01</pubDate>
<description><![CDATA[Python中splitlines()函数的作用是：在定义了行边界的字符串中返回行的列表。除非指定了 keepends 参数，且把其值设置为 True, 否则行的边界符默认不会包含在字符串中。
splitlines()函数的语法格式
str.splitlines( [ keepends ] )
语法中的 str 为要划分行的字符串或字符串变量。
参数 keepends 是可选的，默认为 False，如果指定为 True，则在结果字符串中会包括行的边界符。
行边界符的种类
在Python中定义了以下几种边界符
\n  换行符(Line Feed)
\r  回车符(Carriage...]]></description>
</item>
<item>
<title><![CDATA[Python split()函数的使用]]></title>
<link>/article/python/2020/6453.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-26 12:30:10</pubDate>
<description><![CDATA[Python中 split() 函数是按照指定的分隔符对字符串进行拆分并把拆分结果存储到一个列表里。
一、split()函数语法格式
Python的 split() 函数的语法格式如下：
str.split(sep = None, maxsplit = -1)
str 是要被划分的字符串；
该函数有两个参数，其含义如下：

 sep： 分隔符，split函数将以字符串中的sep为分隔符对字符串进行划分，默认值为None，则按照空白进行划分；
 maxsplit： 最多可划分的数量，指定此参数，将会把原字符串拆分成 maxsplit + 1 部分如果不指定该参数或是-1的话，将不...]]></description>
</item>
<item>
<title><![CDATA[Python replace()函数]]></title>
<link>/article/python/2020/6452.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-25 06:29:51</pubDate>
<description><![CDATA[Python中提供的 replace() 函数的作用是用一个新字符或字符串替换字符串中某个字符串中的原有的字符或子串。Python中 replace() 函数有两种使用形式，一种是简单替换，即使用新字符串替换原字符串中全部与之匹配的子串；另外一种是在替换中指定替换的次数。
一、Python中replace()函数的语法格式
str. replace(old, new [, count])
str 是要执行替换的字符串或字符串变量，各参数的含义如下：

 old ： str 中要被替换的旧字符串；
 new ： 用于替换 str 中的新字符串；
 count ： 可选参数，指定 c...]]></description>
</item>
<item>
<title><![CDATA[Python partition()函数的使用方法]]></title>
<link>/article/python/2020/6451.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-24 17:38:42</pubDate>
<description><![CDATA[Python中 partition() 函数的作用是在首次出现分隔字符串的位置把字符串分割为三部分，并以元组的形式返回分割结果，返回的元组中包括分隔字符串之前的部分，分隔字符串本身及分隔字符串之后的部分。
一、partition()函数的语法格式
string_name.partition(separator)
（1）string_name 为要被分隔的字符串或字符串变量。
（2）该函数有一个字符串类型的参数：separator，该参数用于指定分隔原字符串的字符串；
（3）该函数的返回类型为元组类型，元组中包括了分割后的三部分：

 分隔字符串 separator 之前的部分；
...]]></description>
</item>
<item>
<title><![CDATA[Python upper()函数]]></title>
<link>/article/python/2020/6450.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-23 12:55:25</pubDate>
<description><![CDATA[upper()函数是Python内建的字符串处理函数之一。Python upper() 函数的作用是把一个字符串中所有的字符都转换为其大写形式，并返回一个新字符串。由于Python的字符串是不可变的，这种转换不会影响原字符串的内容与形式。
一、upper()函数的语法格式
string_copy = string_orig . upper()
语法形式中，string_orig 是要进行转换的原字符串；
string_copy 是转换后的字符串副本；
该函数不需要任何参数，执行完成后，返回一个 string 类型。
二、upper()函数使用示例
1、字符串中的字符都为小写形式
...]]></description>
</item>
<item>
<title><![CDATA[Python lower()函数]]></title>
<link>/article/python/2020/6449.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-23 08:15:43</pubDate>
<description><![CDATA[Python中 lower() 函数的作用是把一个字符串中所有大写形式的字符变为小写形式，并生成源字符串的一个副本。
lower() 函数在很多场合起着重要的作用，如有时我们需要判断一个字符串中是否包含另外一个子串，判断文件是否是特定后缀结尾的等，这时我们有必要把源字符串变成小写形式后再判断。毕竟，在实际应用过程中，用户可能使用了大小写不同的形式来表现字符串，将字符串统一变为小写形式能更加准确的进行判别。
一、lower()函数的语法形式
string_copy = string_orig.lower()
string_copy 是将 string_orig 字符串变为小写形式后的字符...]]></description>
</item>
<item>
<title><![CDATA[Python isupper()函数判断字符串字符是否都为大写形式]]></title>
<link>/article/python/2020/6448.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-21 06:11:37</pubDate>
<description><![CDATA[Python中的 isupper() 函数的作用是检查一个字符串中的字符是否都为大写形式，如果字符串不为空，且所有字符都为大写形式的话就返回 True ，否则返回 False 。
可以认为，Python 的 isupper() 函数的作用与 islower() 函数是相反的。后者的作用是检查一个字符串的所有字符是否都为小写形式。
一、isupper()函数的语法形式
str_name.isupper()
str_name是要检查的字符串或字符串变量；
该函数没有参数；
该函数的返回值是逻辑值：True 或 False.
二、isupper()函数使用示例
1、只包含字母且所有字...]]></description>
</item>
<item>
<title><![CDATA[Python isspace()函数]]></title>
<link>/article/python/2020/6445.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-20 06:25:17</pubDate>
<description><![CDATA[Python字符串函数isspace()的作用是检查字符串是否仅包含空白字符，如果字符串仅包含空白字符则返回True，否则返回False。
一、isspace()函数的语法格式
str.isspace()
该函数中，str是要判别的字符串或字符串变量；
该函数没有参数；
该函数的返回值是逻辑值：True 或 False.
二、isspace()函数使用示例
1、基本使用示例
str1 = &quot; &quot; # 6个空格
print(str1.isspace())
str1 = &quot;I am a student.&quot; # 含空格的字符串
print(str1.isspace())
st...]]></description>
</item>
<item>
<title><![CDATA[Python中的转义字符]]></title>
<link>/article/python/2020/6446.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-20 06:01:03</pubDate>
<description><![CDATA[Python在定义一个字符串时，可以灵活使用单引号（&#39;）或双引号（&quot;）来处理字符串中出现单引号或双引号字符的问题，但是在实际操作过程中，我们可能还有其它方面的需求。
比如我们可能在处理输出字符串时，需要回车换行，tab键，退格等，这时，使用转义字符（Escape Character）是非常方便的选择。
那什么是转移字符呢？
转义字符是在字符串中使用特定方法把一个字符转换成替代解释的字符。
在Python中使用反斜杠（\）来定义一个转义字符。
下面先给出字符串中出现单双引号，而未使用转义字符的情景。
str1 = &quot;蚂蚁说：&quot;我要吃掉大象！&quot; &quot;
print(str1)

pr...]]></description>
</item>
<item>
<title><![CDATA[Python isnumeric()函数的使用]]></title>
<link>/article/python/2020/6444.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-19 10:47:12</pubDate>
<description><![CDATA[Python中isnumeric()函数是判断一个字符串是否都由数字形式的字符构成，如果是则返回True，否则返回False.
Python的isnumerice()函数判断的数字形式要比isdecimal()函数和isdigit()函数的范围要广，该函数不仅能够判断十进制形式的数字，特殊性形式的数字（如阿拉伯数字，Unicode编码的上角标数字，带圈的数字），还能够判断像汉字中的“一二三”等这种汉字数字。
一、isnumeric()函数的语法形式
str.isnumeric()
str就是要被检查的字符串或字符串变量；
该函数没有参数；
该函数的返回值是两个逻辑值：True或Fa...]]></description>
</item>
<item>
<title><![CDATA[Python islower()函数 判断字符串中字符是否都为小写]]></title>
<link>/article/python/2020/6443.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-18 06:07:02</pubDate>
<description><![CDATA[Python中提供了一系列的字符串处理函数可以帮我们解决实际中的很多问题。
islower()函数是Python中的另外一个内建字符串处理函数，其作用是判断一个字符串中的所有字母字符是否都为小写拼写形式，如果是则返回True，否则返回False.
一、islower()的语法格式
str.islower()
其中，str是要被判断的字符串或字符串变量；
该函数没有参数；
该函数的返回值为逻辑值：True 或 False.
二、islower()函数使用示例
1、字符串中仅含小写字母
str1 = &quot;hello world!&quot;
print(str1.islower())
输...]]></description>
</item>
<item>
<title><![CDATA[Python isdigit()函数]]></title>
<link>/article/python/2020/6442.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-17 06:31:46</pubDate>
<description><![CDATA[Python isdigit()函数的作用是检查一个字符串中的字符是否全部为数字字符，如果是全部为数字字符则返回True,否则返回False.
isdigit()函数检查的数字字符包括isdecimal()函数检查的数字形式，同时还包括Unicode字符中的上角标数字，如：&sup1;&sup2;&sup3;。
一、Python isdigit()函数的语法格式
str.isdigit()
其中，str是被检查的字符串或字符串变量。
该函数没有参数；
该函数的返回值是逻辑值True或False。
二、Python isdigit()函数使用示例
1、字符串全是由普通数字构成
...]]></description>
</item>
<item>
<title><![CDATA[Python中的isdecimal()函数]]></title>
<link>/article/python/2020/6441.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-16 06:20:24</pubDate>
<description><![CDATA[Python中isdecimal()函数的作用是检查一个字符串是否仅有十进制的数字字符构成。如果是则返回True，否则返回False.
如果一个字符串中包含除十进制数字之外的字符，如空字符串、空格、标点符号、小数点等字符都会认为为False.
一、isdecimal()的语法格式
string_name.isdecimal()
string_name可以是直接给出的字符串或字符串变量。
该函数没有参数。
该函数返回逻辑值：True或False.
二、isdecimal()函数使用示例
1、仅有数字构成的字符串
str1 = &quot;1234&quot;
print(str1.isdecim...]]></description>
</item>
<item>
<title><![CDATA[Python字符串函数isalpha()函数]]></title>
<link>/article/python/2020/6440.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-15 06:58:03</pubDate>
<description><![CDATA[在Python中，字符串处理函数isalpha()的作用是检查一个字符串中所有的字符是否都是由字母构成的，并且至少有1个字符。
如果，字符串中所有的字符都是字母，则返回True，否则返回False.
该函数除了能判断字符串是否为英文字母外，也能判断其它语言中的字母，即Unicode字符库中的&quot;Letter&quot;部分，也就是分类属性中为&quot;Lm&quot;,&quot;Lt&quot;,&quot;Lu&quot;,&quot;LI&quot;或&quot;Lo&quot;的那些字符。
换句话说：isalpha()函数判断的是字符串中的字符是否为构成某个语言的基本字符（如中国的汉字，日语的平假名等），而不是空格，标点符号或特殊字符。
该函数与isalnum()不同之处在于，isal...]]></description>
</item>
<item>
<title><![CDATA[Python中的isalnum()函数]]></title>
<link>/article/python/2020/6439.html</link>
<author>本站</author>
<category><![CDATA[Python]]></category>
<pubDate>2020-06-15 05:23:12</pubDate>
<description><![CDATA[isalnum()函数也是Python内置的一个函数。其作用是检查一个字符串是否由字母或数字组成。
也就是说该函数检查字符串是否由字母[a-z,A-Z]（也包括构成其它语言的字符，如汉字，俄文，日文，韩文）或数字[0-9]及其组合组成的，如果是则返回True，否则返回False。
即，字符串中仅有构成一个语言的有效字符（汉字、韩文、平假名、片假名、俄文等）以及10个数字组成时，则返回True，否则为False.亦即，不能是空字符串，不能有特殊字符，不可打印字符，控制符，标点符号等。
该函数的使用要点：
（1）Python中的isalnum()函数不需要参数；
（2）字符串中包含空格或...]]></description>
</item></channel></rss>

