Python基础二

1.for循环后接else

__author__ = "zhou"
age_of_oldboy = 56
for i in range(3):
    guess_age = int(input("guess age:"))
    if guess_age == age_of_oldboy:
        print("yes,you got it")
        break
    elif guess_age > age_of_oldboy:
        print("think smaller!")
    else:
        print("think bigger!")
else:    #如果for循环正常结束，就执行else下面的代码
    exit("too many attemts...")
print("结束")

for循环

2.while循环及判断用户输入的内容是否是数字。

__author__ = "zhou"
#!/usr/bin/env python
# -*- coding: utf-8 -*-
age_of_oldboy = 56
count = 0
while count < 10:
    guess_age = input("guess age:")
    if guess_age.isdigit():
        guess_age =int(guess_age)
    else:
        continue
    if guess_age == age_of_oldboy:
        print("yes,you got it")
        break
    elif guess_age > age_of_oldboy:
        print("think smaller!")
    else:
        print("think bigger!")
    count +=1

while循环

3.三元运算

result = 值1 if 条件 else 值2

# 如果条件成立，那么将 “值1” 赋值给result变量，否则，将“值2”赋值给result变量

三元运算

4.range

#打印[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print("range(0,10)",list(range(0,10)))
#跳跃打印[0, 2, 4, 6, 8]
print("range(0,10,2)",list(range(0,10,2)))

range

5.变量

变量：用来记录状态

变量值的变化即状态的变化，程序运行的本质就是来处理一系列状态的变化

6.数据类型

 数字；字符串；列表；元祖；字典

6.1数字

Python 支持三种不同的数值类型：

• 整型(Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
• 浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 10² = 250）
• 复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。

数字相关内建函数

6.2字符串

字符串或串(String)是由数字、字母、下划线组成的一串字符。

它是编程语言中表示文本的数据类型。

python的字串列表有2种取值顺序:

• 从左到右索引默认0开始的，最大范围是字符串长度少1
• 从右到左索引默认-1开始的，最大范围是字符串开头

如果你要取得一段子串的话，可以用到变量[头下标:尾下标]，就可以截取相应的字符串，其中下标是从0开始算起，可以是正数或负数，下标可以为空表示取到头或尾。

 例子：

msg20='nihao 123'
print(msg20[-1])
print(msg20[0:3])
print(msg20[0:])
print(msg20[:])
print(msg20[2:7:2])

以上实例输出结果如下：　　

3
nih
nihao 123
nihao 123
ho1

字符串相关内建函数

capitalize()

 Python capitalize()将字符串的第一个字母变成大写,其他字母变小写。

语法

str.capitalize()

参数

• 无

返回值

该方法返回一个首字母大写的字符串。

 实例：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "heLLo World"
print(msg.capitalize())

以上实例输出结果如下：

Hello world

center(width, fillchar)

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

语法

center()方法语法：

str.center(width[, fillchar])

参数

• width -- 字符串的总宽度。
• fillchar -- 填充字符。

返回值

返回一个指定的宽度 width 居中的字符串，如果 width 小于字符串宽度直接返回字符串，否则使用 fillchar 去填充。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "heLLo World"
print(msg.center(20,"*"))

以上实例输出结果如下：

****heLLo World*****

count(str, beg= 0,end=len(string))

count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。

语法

count()方法语法：

str.count(sub, start= 0,end=len(string))

参数

• sub -- 搜索的子字符串
• start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
• end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

返回值

该方法返回子字符串在字符串中出现的次数。

实例

以下实例展示了count()方法的实例：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "heLLo World"
print('msg.count("L")：',msg.count("L"))
print('msg.count("he",0,5)：',msg.count("he",0,5))

以上实例输出结果如下：

msg.count("L")： 2
msg.count("he",0,5)： 1

decode(encoding='UTF-8',errors='strict')

decode() 方法以指定的编码格式解码 bytes 对象。默认编码为 'utf-8'。

语法

decode()方法语法：

bytes.decode(encoding="utf-8", errors="strict")

参数

• encoding -- 要使用的编码，如"UTF-8"。
• errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。

返回值

该方法返回解码后的字符串。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "你好，世界！"
msg_utf8 = msg.encode("UTF-8")
msg_gbk = msg.encode("GBK")
print(msg)
print("UTF-8 编码：",msg_utf8)
print("GBK  编码：",msg_gbk)

print("UTF-8 解码：",msg_utf8.decode("UTF-8"))
print("GBK 解码：",msg_gbk.decode("GBK"))

 以上实例输出结果如下：

你好，世界！
UTF-8 编码： b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c\xef\xbc\x81'
GBK  编码： b'\xc4\xe3\xba\xc3\xa3\xac\xca\xc0\xbd\xe7\xa3\xa1'
UTF-8 解码： 你好，世界！
GBK 解码： 你好，世界！

encode(encoding='UTF-8',errors='strict')

encode() 方法以指定的编码格式编码字符串。errors参数可以指定不同的错误处理方案。

语法

encode()方法语法：

str.encode(encoding='UTF-8',errors='strict')

参数

• encoding -- 要使用的编码，如: UTF-8。
• errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。

返回值

该方法返回编码后的字符串，它是一个 bytes 对象。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "你好，世界！"
msg_utf8 = msg.encode("UTF-8")
msg_gbk = msg.encode("GBK")
print(msg)
print("UTF-8 编码：",msg_utf8)
print("GBK  编码：",msg_gbk)

print("UTF-8 解码：",msg_utf8.decode("UTF-8"))
print("GBK 解码：",msg_gbk.decode("GBK"))

 以上实例输出结果如下：

你好，世界！
UTF-8 编码： b'\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x8c\xe4\xb8\x96\xe7\x95\x8c\xef\xbc\x81'
GBK  编码： b'\xc4\xe3\xba\xc3\xa3\xac\xca\xc0\xbd\xe7\xa3\xa1'
UTF-8 解码： 你好，世界！
GBK 解码： 你好，世界！

endswith(suffix, beg=0, end=len(string))

endswith() 方法用于判断字符串是否以指定后缀结尾，如果以指定后缀结尾返回True，否则返回False。可选参数"start"与"end"为检索字符串的开始与结束位置。

语法

endswith()方法语法：

str.endswith(suffix[, start[, end]])

参数

• suffix -- 该参数可以是一个字符串或者是一个元素。
• start -- 字符串中的开始位置。
• end -- 字符中结束位置。

返回值

如果字符串含有指定的后缀返回True，否则返回False。

实例

#!/usr/bin/env python
# -*- coding: utf- -*-
msg = "Hello world"
print(msg.endswith(,))

以上实例输出结果如下：

True

expandtabs(tabsize=8)

expandtabs() 方法把字符串中的 tab 符号('\t')转为空格，tab 符号('\t')默认的空格数是 8。

语法

expandtabs()方法语法：

str.expandtabs(tabsize=8)

参数

• tabsize -- 指定转换字符串中的 tab 符号('\t')转为空格的字符数。

返回值

该方法返回字符串中的 tab 符号('\t')转为空格后生成的新字符串。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello\tworld"
print(msg)
print(msg.expandtabs())
print(msg.expandtabs(16))

以上实例输出结果如下：

Hello    world
Hello   world
Hello           world

find(str, beg=0 end=len(string))

find() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，如果包含子字符串返回开始的索引值，否则返回-1。

语法

find()方法语法：

str.find(str, beg=0, end=len(string))

参数

• str -- 指定检索的字符串
• beg -- 开始索引，默认为0。
• end -- 结束索引，默认为字符串的长度。

返回值

如果包含子字符串返回开始的索引值，否则返回-1。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello world"
print(msg.find("r"))
print(msg.find("ell"))

以上实例输出结果如下：

8
1

index(str, beg=0, end=len(string))

index() 方法检测字符串中是否包含子字符串 str ，如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，该方法与 python find()方法一样，只不过如果str不在 string中会报一个异常。

语法

index()方法语法：

str.index(str, beg=0, end=len(string))

参数

• str -- 指定检索的字符串
• beg -- 开始索引，默认为0。
• end -- 结束索引，默认为字符串的长度。

返回值

如果包含子字符串返回开始的索引值，否则抛出异常。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello world"
print(msg.index("r"))
print(msg.index("ell"))

以上实例输出结果如下：

8
1

isalnum()

isalnum() 方法检测字符串是否由字母和数字组成。

语法

isalnum()方法语法：

str.isalnum()

参数

• 无。

返回值

如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "HelloWorld"
msg1 = "Hello World"
print(msg.isalnum())
print(msg1.isalnum())

以上实例输出结果如下：

True
False

isalpha()

Python isalpha() 方法检测字符串是否只由字母组成。

语法

isalpha()方法语法：

str.isalpha()

参数

• 无。

返回值

如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "HelloWorld2016"
msg1 = "HelloWorld"
print(msg.isalpha())
print(msg1.isalpha())

以上实例输出结果如下：

False
True

isdigit()

Python isdigit() 方法检测字符串是否只由数字组成。

语法

isdigit()方法语法：

str.isdigit()

参数

• 无。

返回值

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

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "
msg1 = "HelloWorld2016"
print(msg.isdigit())
print(msg1.isdigit())

以上实例输出结果如下：

True
False

islower()

islower() 方法检测字符串是否由小写字母组成。

语法

islower()方法语法：

str.islower()

参数

• 无。

返回值

如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "hello world2016"
msg1 = "Hello World2016"
print(msg.islower())
print(msg1.islower())

以上实例输出结果如下：

True
False

isnumeric()

isnumeric() 方法检测字符串是否只由数字组成。这种方法是只针对unicode对象。

注：定义一个字符串为Unicode，只需要在字符串前添加 'u' 前缀即可，具体可以查看本章节例子。

语法

isnumeric()方法语法：

str.isnumeric()

参数

• 无。

返回值

如果字符串中只包含数字字符，则返回 True，否则返回 False

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "hello world2016"
msg1 = "
print(msg.isnumeric())
print(msg1.isnumeric())

以上实例输出结果如下：

False
True

isspace()

Python isspace() 方法检测字符串是否只由空格组成。

语法

isspace()方法语法：

str.isspace()

参数

• 无。

返回值

如果字符串中只包含空格，则返回 True，否则返回 False.

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "hello world2016"
msg1 = " "
print(msg.isspace())
print(msg1.isspace())

以上实例输出结果如下：

False
True

istitle()

istitle() 方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。

语法

istitle()方法语法：

str.istitle()

参数

• 无。

返回值

如果字符串中所有的单词拼写首字母是否为大写，且其他字母为小写则返回 True，否则返回 False.

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello world2016"
msg1 = "Hello World2016"
print(msg.istitle())
print(msg1.istitle())

以上实例输出结果如下：

False
True

isupper()

isupper() 方法检测字符串中所有的字母是否都为大写。

语法

isupper()方法语法：

str.isupper()

参数

• 无。

返回值

如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello world2016"
msg1 = "HELLO WORLD2016"
print(msg.isupper())
print(msg1.isupper())

以上实例输出结果如下：

False
True

join(seq)

Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

语法

join()方法语法：

str.join(sequence)

参数

• sequence -- 要连接的元素序列。

返回值

返回通过指定字符连接序列中元素后生成的新字符串。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ("H","e","l","l","o")
print("-".join(msg))
print("".join(msg))

以上实例输出结果如下：

H-e-l-l-o
Hello

len(string)

len() 方法返回字符串长度。

语法

len()方法语法：

len( str )

参数

• 无。

返回值

返回字符串长度。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello world2016"
print(len(msg))

以上实例输出结果如下：

15

ljust(width[, fillchar])

ljust() 方法返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

语法

ljust()方法语法：

str.ljust(width[, fillchar])

参数

• width -- 指定字符串长度。
• fillchar -- 填充字符，默认为空格。

返回值

返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello world 2016"
print(msg.ljust(30,"*"))

以上实例输出结果如下：

Hello world 2016**************

lower()

Python lower() 方法转换字符串中所有大写字符为小写。

语法

lower()方法语法：

str.lower()

参数

• 无。

返回值

返回将字符串中所有大写字符转换为小写后生成的字符串。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello World 2016"
print(msg.lower())

以上实例输出结果如下：

hello world 2016

lstrip()

lstrip() 方法用于截掉字符串左边的空格或指定字符。

语法

lstrip()方法语法：

str.lstrip([chars])

参数

• chars --指定截取的字符。

返回值

返回截掉字符串左边的空格或指定字符后生成的新字符串。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "   Hello World 2016"
print(msg.lstrip())

以上实例输出结果如下：

Hello World 2016

maketrans()

maketrans() 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。

注：两个字符串的长度必须相同，为一一对应的关系。

语法

maketrans()方法语法：

str.maketrans(intab, outtab)

参数

• intab -- 字符串中要替代的字符组成的字符串。
• outtab -- 相应的映射字符的字符串。

返回值

返回字符串转换后生成的新字符串。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg16='my name is abcd'
table=str.maketrans('abcd','zhou')
print(msg16.translate(table))

以上实例输出结果如下：

my nzme is zhou

max(str)

max() 方法返回字符串中最大的字母。

语法

max()方法语法：

max(str)

参数

• str -- 字符串。

返回值

返回字符串中最大的字母。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello World 2016"
print(max(msg))

以上实例输出结果如下：

r

min(str)

Python min() 方法返回字符串中最小的字母。

语法

min()方法语法：

min(str)

参数

• str -- 字符串。

返回值

返回字符串中最小的字母。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "HelloWorld2016"
msg1 = "HelloWorld"
print(min(msg))
print(min(msg1))

以上实例输出结果如下：

0
H

replace(old, new [, max])

replace() 方法把字符串中的 old（旧字符串） 替换成 new(新字符串)，如果指定第三个参数max，则替换不超过 max 次。

语法

replace()方法语法：

str.replace(old, new[, max])

参数

• old -- 将被替换的子字符串。
• new -- 新字符串，用于替换old子字符串。
• max -- 可选字符串, 替换不超过 max 次

返回值

返回字符串中的 old（旧字符串） 替换成 new(新字符串)后生成的新字符串，如果指定第三个参数max，则替换不超过 max 次。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello World 2016"
print(msg.replace("lo","xx"))

以上实例输出结果如下：

Helxx World 2016

rfind(str, beg=0,end=len(string))

Python rfind() 返回字符串最后一次出现的位置，如果没有匹配项则返回-1。

语法

rfind()方法语法：

str.rfind(str, beg=0 end=len(string))

参数

• str -- 查找的字符串
• beg -- 开始查找的位置，默认为0
• end -- 结束查找位置，默认为字符串的长度。

返回值

返回字符串最后一次出现的位置，如果没有匹配项则返回-1。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello World 2016"
print(msg.rfind("lo"))

以上实例输出结果如下：

3

rindex( str, beg=0, end=len(string))

rindex() 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间。

语法

rindex()方法语法：

str.rindex(str, beg=0 end=len(string))

参数

• str -- 查找的字符串
• beg -- 开始查找的位置，默认为0
• end -- 结束查找位置，默认为字符串的长度。

返回值

返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello World 2016"
print(msg.rindex("o"))

以上实例输出结果如下：

7

rjust(width,[, fillchar])

rjust() 返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串。

语法

rjust()方法语法：

str.rjust(width[, fillchar])

参数

• width -- 指定填充指定字符后中字符串的总长度.
• fillchar -- 填充的字符，默认为空格。

返回值

返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串。如果指定的长度小于字符串的长度则返回原字符串

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello World 2016"
print(msg.rjust(30,"*"))

以上实例输出结果如下：

**************Hello World 2016

rstrip()

rstrip() 删除 string 字符串末尾的指定字符（默认为空格）.

语法

rstrip()方法语法：

str.rstrip([chars])

参数

• chars -- 指定删除的字符（默认为空格）

返回值

返回删除 string 字符串末尾的指定字符后生成的新字符串。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello World  "
print(msg.rstrip())

以上实例输出结果如下：

Hello World

split(str="", num=string.count(str))

split()通过指定分隔符对字符串进行切片，如果参数num 有指定值，则仅分隔 num 个子字符串

语法

split()方法语法：

str.split(str="", num=string.count(str)).

参数

• str -- 分隔符，默认为空格。
• num -- 分割次数。

返回值

返回分割后的字符串列表。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello World 2016"
print(msg.split(" "))
print(msg.split("o",1))
print(msg.split("e"))

以上实例输出结果如下：

[']
['Hell', ' World 2016']
['H', 'llo World 2016']

splitlines( num=string.count('\n'))

Python splitlines() 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。

语法

splitlines()方法语法：

str.splitlines([keepends])

参数

• keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符。

返回值

返回一个包含各行作为元素的列表。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = """Hello
World
2016"""
msg1 = "Hello \nWorld \n2016"
print(msg.splitlines())
print(msg1.splitlines())

以上实例输出结果如下：

[']
[']

startswith(str, beg=0,end=len(string))

startswith() 方法用于检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False。如果参数 beg 和 end 指定值，则在指定范围内检查。

语法

startswith()方法语法：

str.startswith(str, beg=0,end=len(string));

参数

• str -- 检测的字符串。
• strbeg -- 可选参数用于设置字符串检测的起始位置。
• strend -- 可选参数用于设置字符串检测的结束位置。

返回值

如果检测到字符串则返回True，否则返回False。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello World 2016"
print(msg.startswith("H"))

以上实例输出结果如下：

True

strip([chars])

Python strip() 方法用于移除字符串头尾指定的字符（默认为空格）。

语法

strip()方法语法：

str.strip([chars]);

参数

• chars -- 移除字符串头尾指定的字符。

返回值

返回移除字符串头尾指定的字符生成的新字符串。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "    Hello World    "
msg1 = "****Hello World****"
print(msg.strip())
print(msg1.strip("*"))

以上实例输出结果如下：

Hello World
Hello World

swapcase()

swapcase() 方法用于对字符串的大小写字母进行转换。

语法

swapcase()方法语法：

str.swapcase();

参数

• NA。

返回值

返回大小写字母转换后生成的新字符串。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello World 2016"
print(msg.swapcase())

以上实例输出结果如下：

hELLO wORLD 2016

title()

Python title() 方法返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())。

语法

title()方法语法：

str.title();

参数

• NA。

返回值

返回"标题化"的字符串,就是说所有单词都是以大写开始。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "hello world 2016"
print(msg.title())

以上实例输出结果如下：

Hello World 2016

translate(table, deletechars="")

translate() 方法根据参数table给出的表(包含 256 个字符)转换字符串的字符, 要过滤掉的字符放到 del 参数中。

语法

translate()方法语法：

str.translate(table[, deletechars]);

参数

• table -- 翻译表，翻译表是通过maketrans方法转换而来。
• deletechars -- 字符串中要过滤的字符列表。

返回值

返回翻译后的字符串。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg16='my name is abcd'
table=str.maketrans('abcd','zhou')
print(msg16.translate(table))

以上实例输出结果如下：

my nzme is zhou

upper()

Python upper() 方法将字符串中的小写字母转为大写字母。

语法

upper()方法语法：

str.upper()

参数

• NA。

返回值

返回小写字母转为大写字母的字符串。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello World 2016"
print(msg.upper())

以上实例输出结果如下：

HELLO WORLD 2016

zfill (width)

Python zfill() 方法返回指定长度的字符串，原字符串右对齐，前面填充0。

语法

zfill()方法语法：

str.zfill(width)

参数

• width -- 指定字符串的长度。原字符串右对齐，前面填充0。

返回值

返回指定长度的字符串。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello World 2016"
print(msg.zfill(20))

以上实例输出结果如下：

0000Hello World 2016

isdecimal()

isdecimal() 方法检查字符串是否只包含十进制字符。这种方法只存在于unicode对象。

注意:定义一个十进制字符串，只需要在字符串前添加 'u' 前缀即可。

语法

isdecimal()方法语法：

str.isdecimal()

参数

• 无

返回值

如果字符串是否只包含十进制字符返回True，否则返回False。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = "Hello World 2016"
msg1 = "
print(msg.isdecimal())
print(msg1.isdecimal())

以上实例输出结果如下：

False
True

6.3列表

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

Python有6个序列的内置类型，但最常见的是列表和元组。

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

msg = ["Hello","World",2,0,1,6]

访问列表中的值

使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：

msg = ["Hello","World",2,0,1,6]
print(msg[0:])
print(msg[2:])
print(msg[:-1])

以上实例输出结果如下：

['Hello', 'World', 2, 0, 1, 6]
[2, 0, 1, 6]
['Hello', 'World', 2, 0, 1]

更新列表

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World",2,0,1,6]
print(msg)
msg[1] = "xxoo"
print(msg)

以上实例输出结果：

['Hello', 'World', 2, 0, 1, 6]
['Hello', 'xxoo', 2, 0, 1, 6]

删除列表元素

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World",2,0,1,6]
print(msg)
del msg[1]
print(msg)

以上实例输出结果：

['Hello', 'World', 2, 0, 1, 6]
['Hello', 2, 0, 1, 6]

Python列表截取与拼接

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World",2,0,1,6]
print(msg[2:])
print(msg[-2:])
print(msg[0:] + msg[-2:])

以上实例输出结果：

[2, 0, 1, 6]
[1, 6]
['Hello', 'World', 2, 0, 1, 6, 1, 6]

嵌套列表

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World",2,0,1,6]
msg[1] = msg[0:]
print(msg)
print(msg[1][1])

以上实例输出结果：

['Hello', ['Hello', 'World', 2, 0, 1, 6], 2, 0, 1, 6]
World

列表内建函数

len(list)

len() 方法返回列表元素个数。

语法

len()方法语法：

len(list)

参数

• list -- 要计算元素个数的列表。

返回值

返回列表元素个数。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World",2,0,1,6]
print(len(msg))

以上实例输出结果：

6

max() 方法返回列表元素中的最大值。

语法

max()方法语法：

max(list)

参数

• list -- 要返回最大值的列表。

返回值

返回列表元素中的最大值。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World"]
msg1 = [2,1,0,6]
print(max(msg))
print(max(msg1))

以上实例输出结果：

World
6

min(list)

min() 方法返回列表元素中的最小值。

语法

min()方法语法：

min(list)

参数

• list -- 要返回最小值的列表。

返回值

返回列表元素中的最小值。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World"]
msg1 = [2,1,0,6]
print(min(msg))
print(min(msg1))

以上实例输出结果：

Hello
0

list(seq)

list() 方法用于将元组转换为列表。

注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。

语法

list()方法语法：

list( seq )

参数

• list -- 要转换为列表的元组。

返回值

返回列表。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ("Hello","World",2,0,1,6)
print(list(msg))

以上实例输出结果：

['Hello', 'World', 2, 0, 1, 6]

list.append(obj)

append() 方法用于在列表末尾添加新的对象。

语法

append()方法语法：

list.append(obj)

参数

• obj -- 添加到列表末尾的对象。

返回值

该方法无返回值，但是会修改原来的列表。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World"]
msg1 = [1,2,3]
for i in msg1:
    msg.append(i)
    print(msg)

以上实例输出结果：

['Hello', 'World', 1]
['Hello', 'World', 1, 2]
['Hello', 'World', 1, 2, 3]

list.count(obj)

count() 方法用于统计某个元素在列表中出现的次数。

语法

count()方法语法：

list.count(obj)

参数

• obj -- 列表中统计的对象。

返回值

返回元素在列表中出现的次数。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World"]
print(msg.count("Hello"))

以上实例输出结果：

1

list.extend(seq)

extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

语法

extend()方法语法：

list.extend(seq)

参数

• seq -- 元素列表。

返回值

该方法没有返回值，但会在已存在的列表中添加新的列表内容。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World"]
msg1 = [1,2,3]
msg.extend(msg1)
print(msg)

以上实例输出结果：

['Hello', 'World', 1, 2, 3]

list.index(obj)

index() 函数用于从列表中找出某个值第一个匹配项的索引位置。

语法

index()方法语法：

list.index(obj)

参数

• obj -- 查找的对象。

返回值

该方法返回查找对象的索引位置，如果没有找到对象则抛出异常。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ("Hello","World",2,0,1,6)
print(msg.index(1))

以上实例输出结果：

4

list.insert(index, obj)

insert() 函数用于将指定对象插入列表的指定位置。

语法

insert()方法语法：

list.insert(index, obj)

参数

• index -- 对象obj需要插入的索引位置。
• obj -- 要插入列表中的对象。

返回值

该方法没有返回值，但会在列表指定位置插入对象。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World",2,0,1,6]
msg.insert(1,")
print(msg)

以上实例输出结果：

[', 'World', 2, 0, 1, 6]

list.pop(index)

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

语法

pop()方法语法：

list.pop(index)

参数

• obj -- 可选参数，要移除列表元素的对象。

返回值

该方法返回从列表中移除的元素对象。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World",2,0,1,6]
msg.pop(1)
msg.pop()
print(msg)

以上实例输出结果：

['Hello', 2, 0, 1]

list.remove(obj)

remove() 函数用于移除列表中某个值的第一个匹配项。

语法

remove()方法语法：

list.remove(obj)

参数

• obj -- 列表中要移除的对象。

返回值

该方法没有返回值但是会移除两种中的某个值的第一个匹配项。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World",2,0,1,6]
msg.remove(1)
print(msg)

以上实例输出结果：

['Hello', 'World', 2, 0, 6]

list.reverse()

reverse() 函数用于反向列表中元素。

语法

reverse()方法语法：

list.reverse()

参数

• NA。

返回值

该方法没有返回值，但是会对列表的元素进行反向排序。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World",2,0,1,6]
msg.reverse()
print(msg)

以上实例输出结果：

[6, 1, 0, 2, 'World', 'Hello']

list.sort([func])

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

语法

sort()方法语法：

list.sort([func])

参数

• func -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。

返回值

该方法没有返回值，但是会对列表的对象进行排序。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = [2,0,1,6]
msg1 = ["bb","dd","aa","cc"]
msg.sort()
msg1.sort()
print(msg)
print(msg1)

以上实例输出结果：

[0, 1, 2, 6]
['aa', 'bb', 'cc', 'dd']

list.clear()

clear() 函数用于清空列表，类似于 del a[:]。

语法

clear()方法语法：

list.clear()

参数

• 无。

返回值

该方法没有返回值。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World",2,0,1,6]
msg.clear()
print(msg)

以上实例输出结果：

[]

list.copy()

copy() 函数用于复制列表，类似于 a[:]。

语法

copy()方法语法：

list.copy()

参数

• 无。

返回值

返回复制后的新列表。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","World"]
msg1 = [1,2,3]
msg2 = msg.copy()
msg[1] = msg1
print(msg)
print(msg2)

以上实例输出结果：

['Hello', [1, 2, 3]]
['Hello', 'World']

6.4元组

Python 的元组与列表类似，不同之处在于元组的元素不能修改。

元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

如下实例：

msg = ("Hello","world",2,0,1,6)
msg1 = ("a","b","c","d")
msg2 = (2,0,1,6)

元组中只包含一个元素时，需要在元素后面添加逗号

msg2 = (2,)

访问元组

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ("Hello","world",2,0,1,6)
print(msg[0])
print(msg[1:5])

以上实例输出结果：

Hello
('world', 2, 0, 1)

修改元组

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ("Hello","world",2,0,1,6)
msg1 = ("a","b","c","d")
print(msg + msg1)

以上实例输出结果：

('Hello', 'world', 2, 0, 1, 6, 'a', 'b', 'c', 'd')

删除元组

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

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ("Hello","world",2,0,1,6)
print(msg)
del msg
print (msg)

以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

Traceback (most recent call last):
('Hello', 'world', 2, 0, 1, 6)
  File "E:/python/python/元组内建函数/test.py", line 7, in <module>
    print (msg)
NameError: name 'msg' is not defined

元组内置函数

len(tuple)

计算元组元素个数。

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ("Hello","world",2,0,1,6)
print(len(msg))

以上实例输出结果：

6

max(tuple)

返回元组中元素最大值

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = (2,0,1,6)
print(max(msg))

以上实例输出结果：

6

min(tuple)

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = (2,0,1,6)
print(min(msg))

以上实例输出结果：

0

tuple(seq)

将列表转换为元组

实例

#!/usr/bin/env python
# -*- coding: utf-8 -*-
msg = ["Hello","world",2,0,1,6]
print(tuple(msg))

以上实例输出结果：

('Hello', 'world', 2, 0, 1, 6)