Python

简单：Python是一种代表简单主义思想的语言。阅读一个良好的Python程序就感觉像是在读英语一样。它使你能够专注于解决问题而不是去搞明白语言本身。
易学：Python极其容易上手，因为Python有极其简单的说明文档 。
速度快：Python 的底层是用 C 语言写的，很多标准库和第三方库也都是用 C 写的，运行速度非常快。
免费、开源：Python是FLOSS（自由/开放源码软件）之一。使用者可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。FLOSS是基于一个团体分享知识的概念。
高层语言：用Python语言编写程序的时候无需考虑诸如如何管理你的程序使用的内存一类的底层细节。
可移植性：由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。这些平台包括Linux、Windows、FreeBSD、Macintosh、Solaris、OS/2、Amiga、AROS、AS/400、BeOS、OS/390、z/OS、Palm
OS、QNX、VMS、Psion、Acom RISC OS、VxWorks、PlayStation、Sharp Zaurus、Windows
CE、PocketPC、Symbian以及Google基于linux开发的android平台。
解释性：一个用编译性语言比如C或C++写的程序可以从源文件（即C或C++语言）转换到一个你的计算机使用的语言（二进制代码，即0和1）。这个过程通过编译器和不同的标记、选项完成。 运行程序的时候，连接/转载器软件把你的程序从硬盘复制到内存中并且运行。而Python语言写的程序不需要编译成二进制代码。你可以直接从源代码运行
程序。
在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。这使得使用Python更加简单。也使得Python程序更加易于移植。
面向对象：Python既支持面向过程的编程也支持面向对象的编程。在“面向过程”的语言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在“面向对象”的语言中，程序是由数据和功能组合而成的对象构建起来的。
可扩展性：如果需要一段关键代码运行得更快或者希望某些算法不公开，可以部分程序用C或C++编写，然后在Python程序中使用它们。
可嵌入性：可以把Python嵌入C/C++程序，从而向程序用户提供脚本功能。
丰富的库：Python标准库确实很庞大。它可以帮助处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。这被称作Python的“功能齐全”理念。除了标准库以外，还有许多其他高质量的库，如wxPython、Twisted和Python图像库等等。
规范的代码：Python采用强制缩进的方式使得代码具有较好可读性。而Python语言写的程序不需要编译成二进制代码。 缺点
单行语句和命令行输出问题：很多时候不能将程序连写成一行，如import sys;for i in sys.path:print i。而perl和awk就无此限制，可以较为方便的在shell下完成简单程序，不需要如Python一样，必须将程序写入一个.py文件。
独特的语法 这也许不应该被称为局限，但是它用缩进来区分语句关系的方式还是给很多初学者带来了困惑。即便是很有经验的Python程序员，也可能陷入陷阱当中。

应用

系统编程：提供API（Application Programming Interface应用程序编程接口），能方便进行系统维护和管理，Linux下标志性语言之一，是很多系统管理员理想的编程工具。
图形处理：有PIL、Tkinter等图形库支持，能方便进行图形处理。
数学处理：NumPy扩展提供大量与许多标准数学库的接口。
文本处理：python提供的re模块能支持正则表达式，还提供SGML，XML分析模块，许多程序员利用python进行XML程序的开发。
数据库编程：程序员可通过遵循Python DB-API（数据库应用程序编程接口）规范的模块与Microsoft SQL Server，Oracle，Sybase，DB2，MySQL、SQLite等数据库通信。python自带有一个Gadfly模块，提供了一个完整的SQL环境。
网络编程：提供丰富的模块支持sockets编程，能方便快速地开发分布式应用程序。很多大规模软件开发计划例如Zope，Mnet 及BitTorrent. Google都在广泛地使用它。
Web编程：应用的开发语言，支持最新的XML技术。
多媒体应用：Python的PyOpenGL模块封装了“OpenGL应用程序编程接口”，能进行二维和三维图像处理。PyGame模块可用于编写游戏软件。
pymo引擎：PYMO全称为python memories off，是一款运行于Symbian S60V3,Symbian3,S60V5, Symbian3,
Android系统上的AVG游戏引擎。因其基于python2.0平台开发，并且适用于创建秋之回忆（memories
off）风格的AVG游戏，故命名为PYMO。
黑客编程：python有一个hack的库,内置了你熟悉的或不熟悉的函数，但是缺少成就感。

官方代码样式
标识符
由字母，数值和下划线组成且不能以数字开头，区分大小写。

保留字符
import keyword
keyword.kwlist

False ）内置常量
None ）内置常量
True ）内置常量
and）用于表达式运算，逻辑与操作
as）用于类型转换
assert）断言，用于判断变量或条件表达式的值是否为真
async）3.7.0新增
await）3.7.0新增，只能在通过async修饰的函数中，否则报错SyntaxError
break）中断循环语句的执行
class）用于定义类
continue）继续执行下一次循环
def）用于定义函数或方法
del）删除变量或序列的值
elif）条件语句，与if，else结合使用
else）条件语句，与if，elif结合使用
except）包含捕获异常后的操作代码块，与try，finally结合使用
for）for循环语句
finally）3.7.0新增，用于异常语句，出现异常后，始终要执行finally包含的代码块，与try，except结合使用
from）用于导入模块，与import结合使用
global）定义全局变量
if）条件语句，与elif，else结合使用
import）用于导入模块，与from结合使用
in）判断变量是否在序列中
is）判断变量是否为某个类的实例
lambda）定义匿名函数
nonlocal）用于声明，修改嵌套作用域（enclosing作用域，外层非全局作用域）中的变量
not）用于表达式运算，逻辑非操作
or）用于表达式运算，逻辑非操作
pass）空的类，方法或函数的占位符
raise）异常操作输出
return）用于从函数返回计算结果
try）包含可能会出现异常的语句，与except，finally结合使用
while）循环语句
with）简化python的语句
yield）用于从函数依次返回值

1,在python中，定义变量时是不需要指定变量的类型的
在运行的时候，python解释器，会根据赋值语句等号右侧的数据
自动推导出变量中保存数据的准确类型
str 表示是一个字符串类型

name = "小明"

int 表示是一个整数类型

age = 18

bool表示是布尔类型，真True 或假False

gender = True

float 表示是一个小数类型（浮点数）

height = 1.75
weight = 75.0

2,两个字符串变量之间不能直接使用乘法

price_str = input("苹果的单价：")
weight_str = input("苹果的重量：")
# 1> 将价格转换为小数
price = float(price_str)
# 2> 将重量转换成小数
weight = float(weight_str)
money = price * weight
print(money)

price = float(input("苹果的单价："))
weight = float(input("苹果的重量："))
money = price * weight
print(money)

3,在字符串内部，%s表示字符串替换，%d表示用整数替换，有几个%占位符，后面就跟几个变量或值，顺序要对应好。如果只有一个%，那么括号可以省略。（十进制 %06d，表示显示位数用0补全， %02f 表示小数点后只显示两位）

name = "小明"
print("我的名字叫 %s，请多多关照！" % name)
student_no = 100
print("我的学号是 %04d" % student_no)
price = 8.5
weight = 7.6
money = price * weight
print("输出苹果单价 %.02f 元/斤, 购买了 %.02f 斤, 需要支付 %.02f 元" %(price,weight,money))
scale = 0.25
print("数据比例是 %.2f%%" % (scale * 100))

4,if判断(条件)语句

age = int(input("请输入年龄:"))
if age >= 18:

    print("你已成年，欢迎进入")

else:
    print("禁止进入")
# 这句代码无论条件是否成立都会执行
print("这句代码什么时候执行")

5,and,or,not逻辑运算

# 1 定义一个整数变量age，判断年龄是否正确
age = 130
# 2 要求人的年龄在0 - 120 之间
if age >= 0 and age <= 120:
    print("年龄正确")
else:
    print("年龄不正确")

年龄不正确

# 定义两个整数变量 a_score,b_score,判断成绩
a_score = 40
b_score = 50
# 要求只要有一门成绩 >60 分就合格
if a_score >60 or b_score >60:
    print("通过")
else:
    print("继续努力")

继续努力

# 定义一个布尔型变量 is_employee, 判断是否属于本公司员工
is_employee = False
# 如果不是提示禁止入内
# 在开发中，通常希望某个条件不满足时，可以使用 not
# 如果需要拼接复杂的逻辑计算条件，同样也可能使用到 not
if not is_employee:
    print("禁止入内")

禁止入内

6,elif

# 定义holiday_name 字符串变量记录节日名称
holiday_name = "情人节"
if holiday_name == "情人节":
    print("买玫瑰")
    print("看电影")
elif holiday_name == "平安夜":
    print("买苹果")
    print("吃大餐")
elif holiday_name =="生日":
    print("买蛋糕")
else:
    print("每天都是节日啊")

买玫瑰
看电影

7,if的嵌套

# 定义布尔型变量 has_ticket 表示是否有车票
has_ticket = True
# 定义整数变量 knife_length 表示刀的长度，厘米
knife_length = 3
# 首先检查是否有车票
if has_ticket:
    print("请安检")
    # 安检，检查刀具长度
    if knife_length > 20:
        print("刀具过长，有 %d 厘米" % knife_length)
        print("禁止入内")
    else:
        print("通过")
# 没有车票
else:
    print("请先买票")

请安检
通过

8,石头剪刀布

# 导入随机工具包
# 注意：在导入工具包的时候，应该将导入的语句，放在文件的顶部
import random

# 从控制台输出要出的拳 ——石头(1)/剪刀(2)/布(3)
player = int(input("请输入你要出的拳：石头(1)/剪刀(2)/布(3)："))

# 电脑 随机 出拳
computer = random.randint(1, 3)
print("玩家选择的拳是 %d — 电脑出的拳是 %d" % (player, computer))

# 比较胜负
if ((player == 1 and computer == 2)
        or (player == 2 and computer == 3)
        or (player == 3 and computer == 1)):
    print("胜利")
elif player == computer:
    print("平局")
else:
    print("失败")

9,while循环语句

# 打印 Hello Python
# 定义一个整数变量
i = 0
# 开始循环
while i < 3:
    # 希望在循环内执行的代码
    print("Hello Python")
    # 处理计数器
    i += 1

Hello Python
Hello Python
Hello Python

# 计算0—100 之间所有数字的求和
# 定义最终结果的变量
result = 0
# 定义一个整数变量记录循环次数
i = 0

while i <= 100:
    result += i
    i += 1
print("0到100的数字求和 =%d" % result)

0到100的数字求和 =5050

# 计算0—100 之间所有 偶数 的累积求和结果
result = 0

i = 0
while i <=100:
    # 判断变量 I 中的数值，是否是偶数
    if i % 2 == 0:
        print(i)

        result += i
    i += 1
print("0到100之间所有偶数和 = %d" % result)

0
2
4
6
…
…
98
100
0到100之间所有偶数和 = 2550

10,continue语句跳出本次循环。用来告诉Python跳过当前循环的剩余语句，然后继续进行下一轮循环。

i = 0
while i < 10:
    # continue 某一条件满足时，不执行后续重复代码
    if i == 3:
        # 注意，在循环中，如果使用 continue 之前， 必须确认循环计数是否修改！！！
        i += 1
        continue

    print(i)

    i += 1
print("over")

0
1
2
4
5
6
7
8
9
over

11,break语句用来终止循环语句，即循环语句没有False条件或者序列还没被完全递归完，也会停止执行循环语句。用在while和for中，如果使用嵌套循环，break语句将停止执行最深层的循环，并开始执行下一行代码

i = 0
while i < 10:
    # break 某一条件满足时，退出循环，不再执行
    if i == 3:
        break
    print(i)

    i += 1
print("over")

0
1
2
over

12,循环嵌套

"""
在控制台连续输出五行 * ，每一行 * 的数量依次递增
定义 1 的计数器变量、
row = 1
while row <= 5:
    print("*" * row)
    row += 1
"""
# 连续输出五行 * 且每行依次递增
row = 1
while row <= 5:
    # 每一行打印的 * ，和当前行数相同
    # 增加小循环，负责当前行中，每一列的 * 显示
    col = 1
    while col <= row:
        # print("%d" % col)
        print("*", end="")
        col += 1
    # print("第 %d 行" % row)
    # 目的在于，在一行 * 输出完成后，添加换行！
    print("")
    row += 1

*
**
***
****
*****

13,print函数

`# 在默认情况下，print函数输出内容之后，会自动在内容末尾换行`
# 如果不希望换行，可以在print函数输出内容后面增加，end=""
print("*")
print("*", end="++")
print("***")

*
*++***

14,九九乘法表

row = 1
while row <= 9:
    col = 1
    while col <= row :
        print("%d * %d = %d" % (col, row, col*row), end="\t")
        col += 1
    print("")
    row += 1

1 * 1 = 1	
1 * 2 = 2	2 * 2 = 4	
1 * 3 = 3	2 * 3 = 6	3 * 3 = 9	
1 * 4 = 4	2 * 4 = 8	3 * 4 = 12	4 * 4 = 16	
1 * 5 = 5	2 * 5 = 10	3 * 5 = 15	4 * 5 = 20	5 * 5 = 25	
1 * 6 = 6	2 * 6 = 12	3 * 6 = 18	4 * 6 = 24	5 * 6 = 30	6 * 6 = 36	
1 * 7 = 7	2 * 7 = 14	3 * 7 = 21	4 * 7 = 28	5 * 7 = 35	6 * 7 = 42	7 * 7 = 49	
1 * 8 = 8	2 * 8 = 16	3 * 8 = 24	4 * 8 = 32	5 * 8 = 40	6 * 8 = 48	7 * 8 = 56	8 * 8 = 64	
1 * 9 = 9	2 * 9 = 18	3 * 9 = 27	4 * 9 = 36	5 * 9 = 45	6 * 9 = 54	7 * 9 = 63	8 * 9 = 72	9 * 9 = 81	

15,转义字符

# \t 在控制台输出一个 制表符，协助在输出文本时 垂直方向 保持对齐
print("1\t2\t3")
print("10\t20\t30")

# \n 在控制台输出一个 换行符
print(" hello\n python")

# \" 在控制台输出"
print("\"hello python\"")

1 2 3
10 20 30
hello
python
"hello python"
16,定义调用函数

# 定义函数的格式

# def 函数名（）：
#   函数封装的代码
# def 是 define 的缩写

# 函数名称 应该能表达 函数封装代码 功能
# 函数名称 要符合 标识符的命名规则
def multiple_table():
    row = 1
    while row <= 9:
        col = 1
        while col <= row :
            print("%d * %d = %d" % (col, row, col*row), end="\t")
            col += 1
        print("")
        row += 1

无结果

import py14_定义函数

py14_定义函数.multiple_table()

九九乘法表

17,函数

# 定义好函数之后，只表示这个函数封装了一段代码
# 主动调用函数 才会让函数执行（保留两行空行）


def say_hello():
    """打招呼"""
    print("hello")
    print("hello")
    print("hello")
# 调用函数   函数名() 且不能在函数定义 上方


say_hello()

hello
hello
hello

"""

def sum_2_num():
    对两个数字的求和
    num1 = 10
    num2 = 20
    result = num1 + num2
    print("%d + %d = %d" % (num1,num2,result))
sum_2_num()
"""


def sum_2_num(num1,num2):
    result = num1 + num2
    print("%d + %d = %d" %(num1,num2,result))


sum_2_num(20,60)
`# 参数 增加函数的通用性，针对相同的数据处理逻辑，适应更多的数据
# （具有独立功能的代码块）组织为一个小模块，在需要时调用
# 调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数 传递
# 形参 ：定义函数时小括号中的参数，用来接收参数，在函数内部作为 变量
# 实参 ：调用函数时小括号中的参数，用来把数据传递到 函数内部`

20 + 60 = 80

`# 一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体结果做后续处理。`


def sum_2_num(num1,num2):
    """对两个数字的求和"""
    result = num1 + num2
    # 使用返回值，告诉调用函数一方计算的结果
    return result
    # 注意：return 表示返回，下方代码不会被执行

# 使用变量，来接受函数执行的返回结果
sum_result = sum_2_num(20,60)

print("计算结果: %d"% sum_result)

计算结果: 80

def test1():
    print("*" * 10)


def test2():
    print("-" * 10)
    # 函数的嵌套调用
    test1()

    print("+" * 10)
test2()

----------
**********
++++++++++

def print_line(char,times):
    print(char * times)


def print_lines(a,b):
    """打印多行分割线

    :param a: 分割线使用的字符
    :param b: 重复次数
    """
    row = 0

    while row < 5:
        print_line(a,b)

        row += 1


print_lines("-",5)

-----
-----
-----
-----
-----

18,模块

def print_line(char,times):
    print(char * times)


def print_lines(a,b):
    """打印多行分割线

    :param a: 分割线使用的字符
    :param b: 重复次数
    """
    row = 0

    while row < 5:
        print_line(a,b)

        row += 1

name = "模块"

`# 模块名也是一个标识符，在给python 文件起名的时候，不能 数字开头`

引用

import py17_模块

py17_模块.print_lines("-",50)
print(py17_模块.name)

19，列表

`# List 列表 是python中使用最频繁的数据类型，在其他语言中通常叫做 数组
# 专门用来储存一串信息，用[]定义，数据 之间用 ，
# 列表的 索引 从0开始，（数据在列表的位置编号，也被称 下标）`
name_list = ["a","b","c"]
# 取值和取索引
print(name_list[0])
print(name_list.index("b"))  # index“索引”
# 修改
name_list[2] = "d"
# 增加
name_list.append("e")
#    append 可以向列表末尾追加数据
name_list.insert(3,"f")
#    insert 可以在列表指定索引位置插入
temp_list = ["t","y","u","a","l"]
name_list.extend(temp_list)
#    extend 可以将其他列表内容，追加到当前列表的末尾
# 删除
name_list.remove("a")
#    remove 可以从列表中删除指定的数据，且是第一次出现的数据
name_list.pop()
#    pop 默认情况下可以将列表最后一个元素删除
name_list.pop(0)
#    pop 也可以将列表中指定 数据的索引 删除
del name_list [2]
#    del 关键字本质上是用来将一个变量从内存中删除
# name_list.clear()
#    clear 可以清空列表
# 统计
list_let = len(name_list)
print("列表中包含 %d 个元素" % list_let)
#    len 函数可以统计列表元素的总数
count = name_list.count("y")
print("y出现了 %d 次" % count)
#    count 可以统计列表某一个数据出现的次数
print(name_list)

a
1
列表中包含 6 个元素
y出现了 1 次
['d', 'f', 't', 'y', 'u', 'a']

name_list = ["rr","bb","uu","dd","ee"]
num_list = [5,6,7,2,8]
# 升序
#name_list.sort()
#num_list.sort()

# 降序
#name_list.sort(reverse=True)
#num_list.sort(reverse=True)

# 逆序（反转）
#name_list.reverse()
#num_list.reverse()

print(name_list)
print(num_list)

['rr', 'bb', 'uu', 'dd', 'ee']
[5, 6, 7, 2, 8]

20，for（迭代遍历）

`# 遍历 就是 从头到尾 依次 从列表中获取数据，`
`#   在循环体内部 针对 每一个元素。执行相同的操作`
`# python为了提高列表遍历效率，专门提供迭代iteration遍历`
name_list = ["张三","李四","王五","赵六"]
"""
顺序的从列表中依次获取数据，每一次循环过程中，数据都会保存在
my_name 变量中，在循环体内部可以访问到当前这一次获取的数据

for my_name in 列表变量:
    print("我的名字叫 %s" % my_name)

"""
for my_name in name_list:
    print("我的名字叫 %s" % my_name)

我的名字叫 张三
我的名字叫 李四
我的名字叫 王五
我的名字叫 赵六

21，元组

`# Tuple 元组 以列表类似，不同之处在于元组的元素不能修改
#   元组表示多个元素组成的序列
#  用于存储一串信息，数据之间用，分隔  用（）定义`
info_tuple = ("zhangsan",28,28,2.33)

# 取值索引
print(info_tuple[0])
print(info_tuple.index(2.33))

# 统计计数
print(info_tuple.count("zhangsan"))
#　统计元组中包含元素的个数
print(len(info_tuple))

zhangsan
3
1
4

应用场景

`# 函数的参数和返回值，一个函数可以接收任意多个参数，或者一次返回多个数据
# 格式字符串，格式化字符串后边的 （） 本质上就是一个元组
# 让列表不可以被修改 ，以保存数据安全`
info_tuple = ("小明",18,177)
print("%s 年龄是 %d 身高是 %.2f" %info_tuple)
info_str = "%s 年龄是 %d 身高是 %.2f" %info_tuple
print(info_str)
`# 元组和列表之间的转换
# 使用list函数 可以把元组转换成列表
# 使用 tuple 函数可以把列表转换成元组`

元组遍历

`# 取值 就是从元组中获取存储在指定位置的数据
# 遍历 就是从头到尾 依次从元组中获取数据`
info_tuple = ("zhangsan",30,4.44)


# 使用迭代遍历元组
for my_info in info_tuple:

    # 使用格式字符串拼接 my_info 这个变量不方便！
    # 因为元组中通常保存的数据类型是不同的
    print(my_info)
`# 在Python中，可以使用 for 循环遍历所有非数字型类型的变量：列表，元组，字典，字符串
# 在实际开发中，除非 能够确认元组中的数据类型，否则针对元组的循环遍历需求并不是很多`

zhangsan
30
4.44

22，字典
字典同样可以用来存储多个数据，通常用于存储描述一个 物体 的相关信息
dictionary和列表的区别
列表是有序的对象集合
字典是无序的对象组合
字典用｛｝定义。字典使用 键值对 存储数据，之间用 ，分隔
键 key 是索引
值 value 是数据
键和值之间用 ：分隔
键必须是唯一的，值 可以取任何数据类型，但 键 只能使用字符串，数字或元组

xiaoming = {
    "name": "小明",
            "age":18,
            "gender":True,
            "height":175,
            "weight":75}
print(xiaoming)
`# 字典是一个无序的数据集合，使用print输出字典时，
# 输出顺序和定义的顺序不一致`

{
    'name': '小明', 'age': 18, 'gender': True, 'height': 175, 'weight': 75}

xiaoming_dict = {
    "name":"小明"}

# 取值
print(xiaoming_dict["name"])
# 增加/修改
xiaoming_dict["age"]=18
xiaoming_dict["name"]="xixixxi"

# 删除
xiaoming_dict.pop("name")

print(xiaoming_dict)

小明
{
    'age': 18}

xiaoming_dict = {
    "name":"xiaoming",
                 "age":18}
# 统计键值对数量
print(len(xiaoming_dict))
# 合并字典
temp_dict = {
    "height":176,
             "age":25}

xiaoming_dict.update(temp_dict)
`# 如果被合并的字典中包含已经存在的键值对，会覆盖原有键值对`
# 清空字典
xiaoming_dict.clear()

print(xiaoming_dict)

2
{
    }

字典遍历

xiaoming_dict = {
    "name":"xiaoming",
                 "qq":"1234123",
                 "phone":"12342"}
# 迭代遍历
# 变量 k 是每一次循环中，获取到的键值对的 key
for k in xiaoming_dict:
    print("%s - %s"%(k,xiaoming_dict[k]))

name - xiaoming
qq - 1234123
phone - 12342

应用场景

`# 使用多个键值对，存储描述一个 物体 的相关信息--描述更复杂的数据信息
# 将多个字典 放在一个列表中，在进行遍历，在循环体内部对每一个字典进行 相同的处理`
card_list = [
    {
    "name":"zhangsan",
     "age":19,
     "qq":"12314",
     "phone":"123123"},
    {
    "name":"asdf",
     "age":123,
     "qq":"23123",
     "phone":"1232312"},
    {
    "name":"dasda"},
    {
    "name":"asdfasd"},
]

for card_info in card_list:
    print(card_info)

{
    'name': 'zhangsan', 'age': 19, 'qq': '12314', 'phone': '123123'}
{
    'name': 'asdf', 'age': 123, 'qq': '23123', 'phone': '1232312'}
{
    'name': 'dasda'}
{
    'name': 'asdfasd'}

23，字符串

`# 字符串就是一串字符，是编程语言中表示文本的数据类型
# 在Python 中可以使用 一对双引导 " 或者一对单引号 ' 定义一个字符串
# 大多数情况下使用 " 来定义字符串`
str1 ='我的外号是"asdf"'
print(str1)
`# 虽然可以使用 \" 或者 \' 做字符串转义，但是在实际开发中
    # 如果字符串内部需要 " ,可以使用 ' 定义字符串
    # 反之也可以
#　可以使用　索引　获取字符串中指定位置的字符，索引计数从０开始`
str2 = "hello python"
print(str2[6])
`# 也可以使用 for 循环遍历字符串中每一个字符`
for char in str1:
    print(char)

我的外号是"asdf"
p
我
的
外
号
是
"
a
s
d
f
"

hello_str = "hello hello"
# 统计字符串长度
print(len(hello_str))
# 统计某一子字符串出现的次数
print(hello_str.count("h"))

# 某一子字符串出现的位置
print(hello_str.index("h"))

11
2
0

isspace()判断空白字符如果只包含空格，则返回 True（转义字符为空白字符）
isalnum()判断至少有一个字符并且所有字符都是字母或数字，则返回 True
isalpha()判断至少有一个字符并且所有字符都是字母，则返回 True

space_str = "     \t\n\r"
print(space_str.isspace())

True

isdecimal()判断只包含数字，则返回 True，全角数学
isdigit()判断只包含数字，则返回 True，全角数学，（1），\u00b2（平方）
isnumeric()判断只包含数字，则返回 True，全角数学，中文数字
都不能判断小数

num_str = "1"
print(num_str.isdecimal())
print(num_str.isdigit())
print(num_str.isnumeric())

True
True
True

istitle()判断是标题化的（每个首字母大写），则返回 True
islower()判断包含至少一个区分大小写的字符，并且所有这些（区分大小写）的字符都是小写，则返回 True
isupper()判断包含至少一个区分大小写的字符，并且所有这些（区分大小写）的字符都是大写，则返回 True

hello_str = "hello world"
`# startswith()判断是否已指定字符串开始`
print(hello_str.startswith("he"))
`# endswith()判断是否已指定字符串结束`
print(hello_str.endswith("ld"))
`# find()查找指定字符串，如果指定的字符串不存在，会返回-1`
print(hello_str.find("l"))
`# rfind()同find，但是是从右侧开始
# index()同find，但是如果指定字符串不存在，会报错
# rindex()同index，但是是从右侧开始
# replace()替换字符串,执行完成之后，会返回一个新的字符串`
print(hello_str.replace("world","asdfa"))
`# 且不会修改原有字符串的内容`
print(hello_str)

capitalize()把字符串第一个字符大写
title()把字符串每个单词首字母大写
lower()将字符串中所有大写字符转换为小写
upper()将字符串中的小写字母为大写
swapcase()翻转字符串中的大小写
ljust()左对齐
rjust()右对齐
center()居中对齐
lstrip()截掉字符串左边开始的空白字符
rstrip()截掉字符串右边末尾的空白字符
strip()截掉字符串左右两边的字符

poem = ["\t\n登鹳雀楼",
        "王之涣",
        "白日依山尽\t\n",
        "黄河入海流",
        "欲穷千里目",
        "更上一层楼"]
for poem_str in poem:
    # 先使用strip去除空白字符，在使用center居中
     print("|%s|" % poem_str.strip().center(10,"　"))

|　　　登鹳雀楼　　　|
|　　　王之涣　　　　|
|　　白日依山尽　　　|
|　　黄河入海流　　　|
|　　欲穷千里目　　　|
|　　更上一层楼　　　|