一、Python的基础知识：

*基础知识： ROM是只读内存，用于存储操作系统，存进去以后只能读取不能修改；RAM是随机内存。一般宽带带宽Mb的b是bit位，而音视频内容的大小是单位Mb的b是bytes，字节。苹果手机的三层架构：硬件层+操作系统层+软件层；安卓手机的四层架构：硬件层+linux操作系统层+java虚拟机+软件层；机器语言——汇编语言——中级语言（C语言）——高级语言

—— 关于Python的常识：

* Python的发音与拼写

* Python的作者是Guido van Rossum（龟叔）

* Python正式诞生于1991年

* Python的解释器如今有多个语言实现，我们常用的是CPython（官方版本的C语言实现），其他还有Jython（可以运行在Java平台）、IronPython（可以运行在.NET和Mono平台）、PyPy（Python实现的，支持JIT即时编译）

* Python目前有两个版本，Python2和Python3，最新版分别为2.7.13和3.6.2

* Life is shot, you need Python. 人生苦短，我用Python。

—— Python的优缺点

优点：

简单，免费开源，可移植性，解释性语言（Javascript和Python都是，其他的C是编译型语言），面向对象，万事万物皆对象（相对的是面向过程，只有C语言是面向过程的），可扩展性（只要有人写这个扩展程序，就能完成这个功能），丰富的库（一般库就是框架，但小而精的库，大而全是框架，写程序的一个模板），规范的代码（采用强制缩进使其有很强的可读性）

缺点：

唯一的缺点就是执行效率慢，这个是解释型语言所通有的，同时这个缺点也将被计算机越来越强大的性能所弥补。

—— Python的应用场景

Web自动化，移动端自动化，Web应用开发，操作系统管理、服务器运维的自动化脚本，网络爬虫，科学计算（人工智能，自动驾驶），桌面软件，服务器软件（网络软件），游戏（游戏多是C++和Lua配合来写，Python可以写一些辅助的功能），构思实现，产品早期原型和迭代

*前台：前端（html，浏览器），ios，Android做出的产品；后台：php，python，java，.net后台语言；IDE的意思是集成开发环境；Django和Flask都是Python的框架，程序员会用这些框架写程序，测试时就是测这些框架；Pycharm要运行一个项目，需要有一个interpreter，python解析器，把代码解析成为机器认识的语言。

二、Python的正式学习：

1、注释：

注释的写法:

- 单行注释:只能注释一行；'# ' 号后面的内容都会被注释掉；快捷键: ctrl + / 取消的快捷键: ctrl + /；注释内容是什么都可以,随意写

- 多行注释:可以同时注释多行 (用单行注释也可以实现)；多行注释写法: ''' 注释内容''' 或者 """注释内容"""；多行注释没有快捷键

注释的作用：能够大大增强程序的可读性；能够使用注释进行代码测试；能够帮助我们快速理解别人写的代码与逻辑

补充: python程序中的中文支持:

- python3.x解析器中，是默认支持中文的，但是在python2.x解析器中就需要一定的额外设置才可以

- 如果需要在python2.x的解析器中使用中文,需要在每个.py文件的最前端写上如下代码:

```python

# coding=utf-8

```

否则会报错.

- 另外,python官方建议最好的书写形式为:

```python

# -*- coding:utf-8 -*-

```

当然,这两种都是可行的.作用一样.

2、变量

python中,在程序运行时,可以随着程序的运行更改的量成为变量。简单理解：变量就是用来临时存储数据的容器。

使用变量的好处：提高人效,定义一处,多处使用；提高开发效率；敏捷开发（短周期的开发）；测试自动化

3、变量的类型

程序中,为了更充分的利用内存空间以及更有效率的管理内存，变量是有不同的类型的。

int (有符号整形)， float (浮点数，包括负小数和正小数)，bool (布尔)，str (字符串) —— 全写: string
（Long，长整形，也可以代表八进制和十六进制；Complex，复数型；List，列表；Truple，元祖；Dictionary，字典）

# str(字符串)类型定义的形式: 或者‘字符串的内容’
name = "这里是字符串的内容"

# int(有符号整数)类型定义的形式:
age = 10

# float(浮点数)类型定义的形式:
# 在java中有double（双精度），float是单精度，python中没有double
height = 100.00

# bool(布尔)类型定义的形式: Ture的T要大写，False的F要大写
is_man = True

python自动管理数据类型: 在python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要咱们开发者主动的去说明它的类型，系统会自动辨别。我们可以使用 type(变量的名字或者数值) 来查看变量的类型：

is_man = True
print(type(is_man))

# 得到的结果为:
# <class 'bool'>

4、标识符

关键字,变量名以及我们后面会学习到的函数名,类名，模块名等都是标识符.

标识符有一个大的规则: 由字母、下划线和数字组成，且数字不能开头；标识符区分大小写

标识符有不同的命名形式: 但规则是见名知意

驼峰命名法
* 小驼峰式命名法（lower camel case）：第一个单词以小写字母开始；第二个单词的首字母大写，例如：myName、aDog

* 大驼峰式命名法（upper camel case）：每一个单字的首字母都采用大写字母，例如：FirstName、LastName

* 还有一种命名法是用下划线“_”来连接所有的单词: 比如: send_func

关键字是Python官方规定的一些标识符,我们尽量不要定义成相同的名字,免得出错。

查看关键字: python
# 导入模块
import keyword

# 查看这个python版本的关键字
print(keyword.kwlist)

python3.x中的关键字有:
> and as assert break class continue def del
> elif else except exec finally for from global
> if in import is lambda not or pass
> print raise return try while with yield

也可以在Python Shell（shift+鼠标右键）通过以下命令进行查看当前系统中python的关键字 import keyword
keyword.kwlist

5、输出

格式化输出：指通过print()等函数向指定的地方（比如屏幕）输出指定格式的内容

#一般格式化输出：一个等号叫赋值，两个等号才是等于
name = "xiaohua"
age+=1
print("我的姓名是%s, 年龄是%d" % (name, age))

# 默认情况下 Python使用%f 会保留小数点后面六位
print("我的身高:%.2f" % my_height)

# 如果想打印一个bool值,如果想显示True,或者False 要使用%s
# 如果想显示1 或者 0 要使用%d
# 是否是男性 False
print("是否是男性:%s" % is_man)
# 是否是男性:0
print("是否是男性:%d" % is_man)

#换行输出：在输出的时候，如果有`\n`那么，此时`\n`后的内容会在另外一行显示
#换行符：\n
# 一行显示1234567890，另外一行显示-------
print("1234567890\n-------")

# 单纯一个\ 需要书写两个\\
# 如果我就是想显示你好\n世界
print("你好\\n世界")

# 单纯一个% 需要书写两个%%
num = 98
# 成活率达到了98%
print("成活率达到了%d%%" % num)

#制表符：\t，tab==四个空格
#输出是hello world
print("hello\tworld")

下面是完整的，它可以与％符号使用列表:
| 格式符号 | 转换 |
| ---- | :------------: |
| %c | 字符 |
| %s | 字符串 |
| %d | 有符号十进制整数 |
| %u | 无符号十进制整数 |
| %o | 八进制整数 |
| %x | 十六进制整数（小写字母0x） |
| %X | 十六进制整数（大写字母0X） |
| %f | 浮点数 |
| %e | 科学计数法（小写'e'） |
| %E | 科学计数法（大写“E”） |
| %g | ％f和％e 的简写 |
| %G | ％f和％E的简写 |

6、输入：

python2.x 和 python3.x 输入的区别：

- python2.x ：raw_input() ；input()

- python3.x： input()

- python2.x(raw_input) python3.x(input) ：无论你输入的是什么类型的值,输出的都是字符串类型（这里我们主要用Python3.x）

# 如果想通过打印完成多个变量的输出格式:
# print(变量名1,变量名2,变量名3...)
print(my_name,my_age)

# 姓名: 小明年龄: 22岁
print("姓名:% 年龄:%s岁" %(my_name,my_age))

- python2.x(input)：你输入的是什么类型的值,输出的就是什么类型的

7、运算符

- 算术运算符：

| 运算符 | 描述 | 实例 |
| ---- | ---- | --------------------------------------------------------------------------------------------- |
| + | 加 | 两个对象相加 a + b 输出结果 30 -------------------------------------------------|
| - | 减 | 得到负数或是一个数减去另一个数 a - b 输出结果 -10-----------------------|
| * | 乘 | 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200--- |
| / | 除 | b / a 输出结果 2----------------------------------------------------------------------- |
| // | 取整除 | 返回商的整数部分 9//2 输出结果 4 , 9.0//2.0 输出结果 4.0------------- |
| % | 取余 | 返回除法的余数 b % a，b=20，a=10，输出结果 0----------------------|
| ** | 指数 | a**b 为10的20次方，输出结果 100000000000000000000 --------------|

注意：混合运算时，优先级顺序为： `**` 高于 `*` `/` `%` `//` 高于 `+` `-` ，为了避免歧义，建议使用 `()` 来处理运算符优先级。

并且，不同类型的数字在进行混合运算时，整数将会转换成浮点数进行运算。

- 赋值运算符：

-- 赋值运算符：
| 运算符 | 描述 | 实例 |
| ---- | ----- | ----------------------------------------------------------------------------------------------------------|
| =| 赋值运算符 | 把 = 号右边的结果赋给左边的变量，如 num=1 + 2 * 3，结果num的值为7|

-- 复合赋值运算符：可以少创建变量，少占用内存
| 运算符 | 描述 | 实例 |
| ------ | ---------------- | --------------------------------------|
| += | 加法赋值运算符 | c += a 等效于 c = c + a--|
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a-----|
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a-----|
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a------|
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a-|
| **= | 幂赋值运算符 | c **= a 等效于 c = c **a----|
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a--|

8、数据类型转换：

| 函数 | 说明 |
| ---------------------- | ----------------------------- |
| int(x [,base ]) | 将x转换为一个整数 |
| float(x ) | 将x转换为一个浮点数 |
| complex(real [,imag ]) | 创建一个复数，real为实部，imag为虚部 |
| str(x ) | 将对象 x 转换为字符串 |
| repr(x ) | 将对象 x 转换为表达式字符串 |
| eval(str ) | 用来计算在字符串中的有效Python表达式,并返回一个对象 |
| tuple(s ) | 将序列 s 转换为一个元组 |
| list(s ) | 将序列 s 转换为一个列表 |
| chr(x ) | 将一个整数转换为一个Unicode字符 |
| ord(x ) | 将一个字符转换为它的ASCII整数值 |
| hex(x ) | 将一个整数转换为一个十六进制字符串 |
| oct(x ) | 将一个整数转换为一个八进制字符串 |
| bin(x ) | 将一个整数转换为一个二进制字符串 |

# 了解
# eval会自动帮我们识别去掉""以后的内容是否是python里面常见的类型，
# 如果是，转换成对应的类型，常用来转换int和float
my_str3 = "2323"
ret = eval(my_str3)
print(type(ret))
print(ret)
# eval往往会配合input使用
result = eval(input("请输入一个数字:"))
print(type(result))
print(result)

# bool不参与转换

三、顺序结构

指的是代码按照从上往下的流程,依次顺序执行.

四、分支结构（选择结构）

1、if判断语句

格式：
if 要判断的条件:
条件成立时，要做的事情
...

# 例子：定义一个变量flag 如果flag为True,代表没有危险品,可以进入
flag = True
# 判断
if flag:
print("您没有携带危险品,可以进入火车站!!!")

- 如果某些条件满足，才能做某件事情；条件不满足时，则不能做，这就是所谓的判断。

- 不仅生活中有，在软件开发中"判断"功能也经常会用到

- 能够看得出if判断语句的作用：就是当满足一定条件时才会执行代码块语句，否则就不执行代码块语句

- 代码的缩进为一个tab键，或者4个空格

2、比较(即关系)运算符

python中的比较运算符如下表
| 运算符 | 描述 | 示例 |
| ---- | -------------------------------- | ------------------------- |
| == | 检查两个操作数的值是否相等，如果是则条件变为真。 | 如a=3,b=3，则（a == b) 为 True |
| != | 检查两个操作数的值是否相等，如果值不相等，则条件变为真。 | 如a=1,b=3，则(a != b) 为 True |
| > | 检查左操作数的值是否大于右操作数的值，如果是，则条件成立。 | 如a=7,b=3，则(a > b) 为 True |
| < | 检查左操作数的值是否小于右操作数的值，如果是，则条件成立。 | 如a=7,b=3，则(a < b) 为 False |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立。 | 如a=3,b=3，则(a >= b) 为 True |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立。 | 如a=3,b=3，则(a <= b) 为 True |

3、逻辑运算符

| 运算符 | 逻辑表达式 | 描述 | 实例 |
| ---- | ------- | ---------------------------------------- | ------------------------------------ |
| and | x and y | 布尔"与"：如果 x 为 False，x and y 返回 False，否则它返回 y 的值。 | True and False，返回 False。 |
| or | x or y | 布尔"或"：如果 x 是 True，它返回 True，否则它返回 y 的值。 | False or True，返回 True。 |
| not | not x | 布尔"非"：如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。 | not True 返回 False, not False 返回 True |

#例子：
is_man = False
if not is_man:
print("是女性")

4、if-else

# 书写格式
if 条件:
    满足条件时要做的事情1
    满足条件时要做的事情2
    满足条件时要做的事情3
...(省略)...
else:
    不满足条件时要做的事情1
    不满足条件时要做的事情2
    不满足条件时要做的事情3
    ...(省略)...

is_man = not True
if is_man:
print("是女的")
else:
print("是男的")

5、elif

if xxx1:
    事情1
elif xxx2:
    事情2
elif xxx3:
    事情3
else:
事情4

说明:
- 当xxx1满足时，执行事情1，然后整个if结束
- 当xxx1不满足时，那么判断xxx2，如果xxx2满足，则执行事情2，然后整个if结束
- 当xxx1不满足时，xxx2也不满足，如果xxx3满足，则执行事情3，然后整个if结束
- 可以与else一起使用
- elif必须和if一起使用，否则出错
- else 一般用在最后，即所有条件都不满足时使用
- elif是else if的缩写,但是python里面不支持else if的写法, 故只能用elif.
- if 语句和 elif 语句以及 else语句都是互斥的,只有一种情况能够执行,不可能同时执行多个
- 整体句式就是要么...... 要么........ 要么...... 要么..... .........

6、if嵌套

if 条件1:
    满足条件1 做的事情1
    满足条件1 做的事情2
    ...
    if 条件2:
        满足条件2 做的事情1
        满足条件2 做的事情2
        ...

说明
- 外层的if判断，也可以是if-else
- 内层的if判断，也可以是if-else
- 根据实际开发的情况，进行选择

例子：
chePiao = 1 # 用1代表有车票，0代表没有车票
daoLength = 9 # 刀子的长度，单位为cm
if chePiao == 1:
    print("有车票，可以进站")
    if daoLength < 10:
        print("通过安检")
        print("终于可以见到Ta了，美滋滋~~~")
    else:
        print("没有通过安检")
        print("刀子的长度超过规定，等待警察处理...")
else:
    print("没有车票，不能进站")
    print("亲爱的，那就下次见了")

用if语句写猜拳游戏：
# 导入模块 ---> 随机模块
import random

# 定义一个变量记录用户(玩家)的输入(拳法):
player = int(input("请输入:剪刀(0) 石头(1) 布(2):"))

# 定义一个变量记录电脑的输入
computer = random.randint(0,2) #0,1,2

# 以玩家为第一视角:
# 假如说玩家胜利(剪刀 = 布或者石头 = 剪刀或者布 = 石头)
# 假如说玩家和电脑平局(玩家输入的 == 电脑输入的)
# 假如说玩家失败(除了胜利和平局其他都是失败)

# 玩家胜利
if (player == 0 and computer == 2) or (player == 1 and computer == 0) or (player == 2 and computer == 1):
    print("玩家胜利")
elif (player == computer):
    print("玩家和电脑达成平局")
else:
    print("玩家失败")

五、循环结构

1、while循环

i = 0
while i < 5:
    print("当前是第%d次执行循环" % (i + 1))
    print("i=%d" % i)
    i+=1

# 写while循环的时候一定要注意:
# 定义一个变量, 切记要对变量进行加1 或者减1 (等等)操作
# 否则会形成死循环

* while和if的用法基本类似，区别在于：

if 条件成立，则执行一次； while 条件成立，则重复执行，直到条件不成立为止。

* 一般情况下，需要**多次重复**执行的代码，都可以用循环的方式来完成

* 循环不是必须要使用的，但是为了提高代码的重复使用率，所以有经验的开发者都会采用循环

* 不可以停止的循环(判断条件一直满足) 称之为死循环, 在开发中我们应该尽量防止死循环,因为死循环太浪费设备性能.

* while循环内部的代码需要进行缩进,python对缩进要求非常严格.

2、while循环嵌套：实际写代码时，不要嵌套超过3次

* while循环嵌套: 外面的循环执行一次,内部循环会执行n次,一直到执行完毕,再执行外部的循环.

* 无论是内部的while循环还是外部的while循坏都需要定义一个变量, 作为循环次数的记录

* 内部while和外部while都需要对变量进行累加操作. 以保证循环次数的减少

例子1：打印：
*
* *
* * *
* * * *
* * * * *

# 定义一个变量记录行数
row = 1
while row <= 5:

# 定义一个变量记录列数
    col = 1
    while col <= row:
        print("*", end="")
        col += 1

# 在默认的情况下使用print 默认打印完成后会有一个换行
# print("哈哈") 完整的格式 print("哈哈", end="\n")
# 换行
    print("")
    row += 1

例子2：打印：
*
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
*

row = 1
while row <= 9:
    if row <= 5:
        col = 1
        while col <= row:
            print("*", end="")
            col += 1
        print("")
    else:
        col = 9
        while col >= row:
            print("*", end="")
            col -= 1
        print("")
    row += 1

例子3：九九乘法表
# 定义一个变量记录行数
# %2d 显示两位如果只有一位使用空格站位默认为右对齐
# 如果左对齐就是 %-2d
x = 1
while x <= 9:
    y = 1
    while y <= x:
        print("%d * %d =%2d\t" %(y,x,y*x),end="")
        y += 1
    # 换行
    print()
x += 1

3、for循环

在Python中 for循环可以遍历任何序列的项目，如一个列表或者一个字符串等。

```
for 临时变量 in 列表或者字符串等可迭代对象:
        循环满足条件时执行的代码
```

例子：
name = 'itheima'
for x in name:
     print(x)

for循环后面可以跟随一个else.构成for......else句式: (也可以不要else,具体看需求)
```
for 临时变量 in 列表或者字符串等可迭代对象:
        将会执行的语句
else:
        for循环执行完毕之后,会执行调用的语句
```

总结：

* for循环中的"临时变量" 的作用范围仅仅是当前for循环体中缩进的区域

* for循环判断的条件依然是 for 后面的条件是否为True,为True则可以进入,否则不允许进入循环体.

* for循环中的in是个关键字写for循环的时候不能够去掉in

补充知识:

python中 range() 函数用法:

函数语法： range(start, stop[, step])

参数说明：

- start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;

- stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5）是[0, 1, 2, 3, 4]没有5

- step：步长，默认为1。例如：range（0， 5）等价于 range(0, 5, 1)

4、break 和 continue

1) break

break能够打破循环(这里的循环指的是一切循环(例如: for循环和while循环)),break的作用：立刻结束break所在的整个循环

for循环中调用break：如果执行了break for循环将终止 break后面的也就不再执行 (直接跳出循环)
name = 'itheima'
for x in name:
  print('----')
  if x == 'e':
      break
  print(x)
else:
  print("==for循环过程中，如果没有执行break退出，则执行本语句==")

运行结果:
----
i
----
t
----
h
----

while循环中调用break：如果执行了break while循环将终止 break后面的也就不再执行 (直接跳出循环)
i = 0
while i<5:
    i = i+1
    print('----')
    if i==3:
        break
    print(i)
else:
    print("==while循环过程中，如果没有执行break退出，则执行本语句==")

运行结果:
----
1
----
2
----

2) continue

continue的作用：用来结束**本次**循环，紧接着执行下一次的循环

for循环中使用continue:如果在for中如果执行了continue 将提前结束本次循环 continue后面的代码将不再执行
name = 'itheima'
for x in name:
    print('----')
    if x == 'e':
        continue
    print(x)
else:
    print("==for循环过程中，如果没有break则执行==")

运行结果:
----
i
----
t
----
h
----
----
i
----
m
----
a
==for循环过程中，如果没有break则执行==

while循环中使用continue :如果执行了continue 将提前结束本次循环 continue后面的代码将不再执行
i = 0
while i<5:
    i = i+1
    print('----')
    if i==3:
        continue
    print(i)

运行结果:
----
1
----
2
----
----
4
----
5

总结:

- break/continue只能用在循环中，除此以外不能单独使用

- break/continue在嵌套循环中，只对最近的一层循环起作用

- continue是结束单次循环,break是结束整个循环,注意对比记忆

六、字符串

1、字符串的介绍

— 什么是字符串：它是编程语言中表示文本的数据类型。字符串就是有序的字符序列.(顺序是不可以改变的)

— python中字符串的定义方式：

Python中字符串的定义:

* 双引号定义形式例如: a = "hello python"

* 单引号定义形式例如: b = '你好中国, 你好Python'

两者定义出来的字符串是完全相同的. 使用哪种形式都可以

— 字符串输出：在程序中我们可以通过print()方法输出字符串

— 字符串输入：之前在学习input的时候，通过它能够完成从键盘获取数据，然后保存到指定的变量中；注意：input获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存

# 定义一个空的字符串 '' 或者 "" 或者 str()
# 空字符串代表的就是字符串中没有一个字符，空字符串长度为0
# python中提供了一个len函数(内置函数) 计算字符串中的字符个数
# 保留其文本格式可以使用三引号(" 或者 ')
my_str ='''哈喽你好你好你好你好你好你好
你好世界世界世界世界
世界世界世界世界世界
哈喽你好你好你好你好你好你好
你好世界世界世界世界
世界世界世界世界世界'''
print(len(my_str))

总结:

* 字符串就是一组字符的有序集合.

* 字符串有三种表现形式: 用 ' ' 或者 " " 包裹 , 也可以用多行注释的形式表示变量名 = '''字符串内容''' 或者变量名 = """字符串内容"""

* 想要查看字符串的类型, 我们可以调用方法 type(字符串变量名)

* 想要获取字符串的长度, 我们可以使用 len(字符串变量名) 来查看

* 字符串可以是我们平时说的话语,也可以是某一类描述, 任何内内容都可以充当字符串内容.

2、字符串的下标和切片

1）下标：所谓`“下标”`，就是编号.

如果想取出部分字符，那么可以通过`下标`的方法，（注意python中下标从 0 开始）

一定要保证字符串的下标索引是存在的

**小结:**

* 无论是字符串中还是别的(我们即将会讲到的列表和元组), 下标索引值都是从0开始的

* 下标索引值类似于当前位置的坐标. 或者是编号

* 以字符串举例: 这里所标识的是**字符串**中每个**字符**的位置编号

* 下标索引值可以从左侧算起也可以从右侧算起:

* 从左侧算起: 0, 1, 2, 3, 4.......

* 从右侧算起: -1, -2, -3, -4.......

2) 切片

切片是指截取某一对象其中一部分的操作。 (**字符串、列表、元组**都支持切片操作。)

切片的语法：[起始:结束:步长]

* 切片是半开半闭区间即: 包含起始位置, 但是不包含结束位置数学表示: [起始: 结束)

# 切片的语法：[起始:结束(开区间):步长]，步长不写默认是1
# 字符串是不可变的(复制版的)
a = "abcdef"

# 'abc' -> a[0:3] 或者 a[:3] 或者a[-6:-3]
# 如果是从头部开始 0可以省略
ret1 = a[:3]
print(ret1)

# 验证字符串是不可变的
print(a)

# 'ace' a[:5:2] 或者 a[0:5:2] 或者 a[::2]
#默认步长是1
ret2 = a[::2]
print(ret2)

# 'bd'
ret3 = a[1:4:2]
print(ret3)

# 'fdb' 或者a[-1::-2]
ret4 = a[::-2]
print(ret4)

# 'fd' 或者a[:-5:-2]
ret5 = a[-1:-4:-2]
print(ret5)

总结:

* 我们可以从字符串中获取相对应的字符,使用切片的方式,也可以使用下标索引的方式.

* 使用切片的方式获取比较方便,可以根据公司的需求来进行

* 字符串无论怎样切片,修改的都不是原来的字符串,而是复制出来的新字符串

* 字符串切片需要遵循的格式: 字符串名称 [ 起始 : 结束 : 步长 ] 其中结束的索引值不包含

* 字符串切片可以从左侧也可以从右侧进行. 相对应的索引值不同:

* 从左侧进行: 索引值为:0, 1, 2, 3, 4.....

* 从右侧进行: 索引值为:-1, -2, -3, -4.....

* 从右侧进行切片的时候,需要注意步长也为**负数**,否则仍然是从左侧进行.

3、字符串的常见操作：

1) find

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

find()方法语法：str.find(str, beg=0, end=len(string))

> sub: 要查找的**小字符串**

> start: beg -- 开始索引，默认为0。

> end: end -- 结束索引，默认为字符串的长度。（左开右闭）

例如:

mystr = "hello world itcast and itcastcpp"

mystr.find("itcast")

结果:

12

2) index

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

index()方法语法：str.index(str, beg=0, end=len(string))

> str : 指定检索的字符串

> beg: 开始索引，默认为0。

> end: 结束索引，默认为字符串的长度。（左开右闭）

例如:

mystr = 'hello world itcast and itcastcpp'

mystr.find('itcast', 0, 10)

mystr.index('itcast', 0, 10)

结果:

-1

Traceback (most recent call last):

File "<stdin>", line 4, in <module>

ValueError: substring not found

3) count

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

count()方法语法：str.count(sub, start= 0,end=len(string))

> sub: 搜索的子字符串

> start: 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。

> end: 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

例如:

mystr = 'hello world itcast and itcastcpp'

mystr.count("itcast")

结果:

2

4) replace

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

replace()方法语法：str.replace(old, new[, max])

> old -- 将被替换的子字符串。

> new -- 新字符串，用于替换old子字符串。

> max -- 可选字符串, 替换不超过 max 次

name = 'hello world ha ha'

name.replace("ha", "Ha")

name.replace("ha", "Ha", 1)

结果:

'hello world Ha Ha'

'hello world Ha ha'

5) split

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

split()方法语法：str.split(str="", num=string.count(str)).

> str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。

> num -- 分割次数。

name = 'hello world ha ha'

name.split(" ")

name.split(" ", 2)
name.split("l")

结果:

['hello', 'world', 'ha', 'ha']
['hello', 'world', 'ha ha']
['he','','0 wor','d ha ha'] —— ''这里面有这个空字符串

6) capitalize

> Python capitalize()将字符串的第一个字母变成大写,其他字母变小写。对于 8 位字节编码需要根据本地环境。

capitalize()方法语法：str.capitalize()

例如:

mystr = 'hello world itcast And Itcastcpp'

print(mystr.capitalize())

结果:

'Hello world itcast and itcastcpp'

7) title

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

title()方法语法：str.title();

例如:

a = "hello itcast and itcastCPP"

a.title()

结果:

'Hello Itcast And Itcastcpp'

8) startswith

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

startswith()方法语法：str.startswith(str, beg=0,end=len(string));

> str -- 检测的字符串。

> strbeg -- 可选参数用于设置字符串检测的起始位置。

> strend -- 可选参数用于设置字符串检测的结束位置。

例如:

mystr = 'hello world itcast and itcastcpp'

mystr.startswith("hello")

mystr.startswith("Hello")

结果:

True

False

9) endswith

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

endswith()方法语法：str.endswith(suffix[, start[, end]])

> suffix -- 该参数可以是一个字符串或者是一个元素。

> start -- 字符串中的开始位置。

> end -- 字符中结束位置。

例如:

mystr = 'hello world itcast and itcastcpp'

mystr.endswith('cpp')

mystr.endswith('app')

结果:

True

False

10) lower

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

lower()方法语法：str.lower()

例如:

mystr = 'HELLO World itcast and itcastcpp'

mystr.lower()

结果:

'hello world itcast and itcastcpp'

11) upper

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

upper()方法语法：str.upper()

例如:

mystr = 'HELLO World itcast and itcastcpp'

mystr.upper()

结果:

'HELLO WORLD ITCAST AND ITCASTCPP'

12) ljust

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

ljust()方法语法：str.ljust(width[, fillchar])

> width -- 指定字符串长度。

> fillchar -- 填充字符，默认为空格。

例如:

mystr = 'hello'

ret = mystr.ljust(10,'*')

print(ret)

结果:

'hello*****'

13) rjust

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

rjust()方法语法：str.rjust(width[, fillchar])

> * width -- 指定填充指定字符后中字符串的总长度.

> - fillchar -- 填充的字符，默认为空格

例如:

mystr = "hello"

ret = mystr.rjust(10, '*')

print(ret)

结果:

*****hello

14) center

> Python center() 返回一个原字符串居中,并使用空格填充至长度 width 的新字符串。默认填充字符为空格。

center()方法语法：str.center(width[, fillchar])

> - width -- 字符串的总宽度。

> - fillchar -- 填充字符。

例如:

mystr = 'hello world itcast and itcastcpp'

ret = mystr.center(50,'@')

print(ret)

结果:

@@@@@@@@@hello world itcast and itcastcpp@@@@@@@@@

15) lstrip

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

lstrip()方法语法：str.lstrip([chars])

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

例如:

str = " this is string example....wow!!! ";

print str.lstrip(); #如果是lstrip(' t')或者lstrip('t ')都可以删除前面的空格和t，
#但是如果是lstrip('t')，则不能删除前面的空格和t，因为原字符串不是t开头

str = "88888888this is string example....wow!!!8888888";

print str.lstrip('8');

结果:

this is string example....wow!!!

this is string example....wow!!!8888888

16) rstrip

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

rstrip()方法语法：str.rstrip([chars])

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

例如:

mystr = ' hello '

ret = mystr.rstrip()

print(ret)

结果:

' hello'

17) strip

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

strip()方法语法：str.strip([chars]);

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

例如:

a = '\n\t itcast \t\n'

ret = a.strip()

print(ret)

结果:

'itcast'

18) rfind

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

rfind()方法语法：str.rfind(str, beg=0 end=len(string))

> - str -- 查找的字符串

> - beg -- 开始查找的位置，默认为 0

> - end -- 结束查找位置，默认为字符串的长度。

例如:

mystr = 'hello world itcast and itcastcpp' #查询时从右往左查，但位置是按左往右算的

ret = mystr.rfind("itcast")

print(ret)

结果:

23

19) rindex

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

rindex()方法语法：str.rindex(str, beg=0 end=len(string))

> - str -- 查找的字符串

> - beg -- 开始查找的位置，默认为0

> - end -- 结束查找位置，默认为字符串的长度。

例如:

mystr = 'hello world itcast and itcastcpp'

ret1 = mystr.rindex('it')

print(ret1)

ret2 = mystr.rindex("IT")

print(ret2)

结果:

23

Traceback (most recent call last):

File "<stdin>", line 4, in <module>

ValueError: substring not found

20) partition

> partition() 方法用来根据指定的分隔符将字符串进行分割。

> 如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。

> partition() 方法是在2.5版中新增的。

partition()方法语法：str.partition(str)

> str : 指定的分隔符。

例如:

mystr = 'hello world itcast and itcastcpp'

ret = mystr.partition('itcast')

print(ret)

结果:

('hello world', 'itcast', ' and itcastcpp')

21) rpartition

> 类似于 partition()函数,不过是从右边开始.

rpartition()方法语法：str.partition(str)

> str : 指定的分隔符。

例如:

mystr = 'hello world itcast and itcastcpp'

ret1 = mystr.partition('itcast')

print(ret1)

ret2 = mystr.rpartition('itcast')

print(ret2)

结果:

('hello world', 'itcast', ' and itcastcpp')

('hello world itcast and ', 'itcast', 'cpp')

22) splitlines

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

splitlines()方法语法：str.splitlines([keepends])

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

例如:

mystr = 'hello\nworld'

print(mystr)

ret = mystr.splitlines()

print(ret)

结果:

hello

world

['hello', 'world']

23) isalpha

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

isalpha()方法语法：str.isalpha()

例如:

mystr = 'abc'

ret1 = mystr.isalpha()

print(ret1)

mystr1 = '123'

ret2 = mystr.isalpha()

print(ret2)

mystr2 = 'abc 123'

ret3 = mystr2.isalpha()

print(ret3)

结果:

True

False

False

24) isdigit

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

isdigit()方法语法：str.isdigit()

例如:

mystr1 = 'abc'

ret1 = mystr1.isdigit()

print(ret1)

mystr2 = '123'

ret2 = mystr2.isdigit()

print(ret2)

mystr3 = 'abc123'

ret3 = mystr3.isdigit()

print(ret3)

结果:

False

True

False

25) isalnum

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

isalnum()方法语法：str.isalnum()

例如:

mystr1 = '123'

ret1 = mystr.isalnum()

print(ret1)

mystr2 = 'abc'

ret2 = mystr2.isalnum()

print(ret2)

mystr3 = 'abc123'

ret3 = mystr3.isalnum()

print(ret3)

mystr4 = 'abc 123'

ret4 = mystr4.isalnum()

print(ret4)

结果:

True

True

True

False

26) isspace

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

isspace()方法语法：str.isspace()

例如:

mystr = 'abc123'

ret = mystr.isspace()

print(ret)

mystr1 = ''

ret1 = mystr1.isspace()

print(ret1)

mystr2 = ' '

ret2 = mystr2.isspace()

print(ret2)

mystr3 = ' '

ret3 = mystr3.isspace()

print(ret3)

结果:

False

False

True

True

27) join

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

join()方法语法：str.join(sequence) 是字符串.join()

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

例如:

str = ' '

li = ['my', 'name', 'is', 'meiZong']

ret = str.join(li)

print(ret)

str1 = '_'

ret1 = str1.join(li)

print(ret1)

结果:

'my name is meiZong'

'my_name_is_meiZong'

补充知识：

# 内置函数help：对字符串不了解不知道他有什么特点有哪些方法，或者对他的方法不熟悉

my_str = "hello"

print(type(my_str))

# 查找

help(str.lower)

# 如果查看一个类的所有方法，首先要确定他的类型 -> type(数值) <class "类型">，help(类型)，如果查看这个类型的指定的方法，help(类型.方法名)

总结：

* 字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。

* 创建字符串很简单，只要为变量分配一个值即可。例如：var1 = 'Hello World!'

* Python不支持单字符类型，单字符在 Python 中也是作为一个字符串使用。

* Python访问子字符串，可以使用方括号来截取字符串

* 你可以对已存在的字符串进行修改，并赋值给另一个变量, 字符串不支持修改.

* Python 支持格式化字符串的输出。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。

* python三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。

三引号的语法是一对连续的单引号或者双引号（通常都是成对的用）。

七、列表

1、列表的介绍：

列表: 和变量一样,列表也是一个容器,该容器能够存储多种数据类型.

# 格式: 列表名 = [元素1, 元素2, 元素3,....]

my_list = ["xiaoming", "xiaohong"]

# # -> 支持下标索引

my_name = my_list[0]

print(my_name)

# 需求我想打印hello (从左到右) 0, 1, 2,....

# 也可以从右到左 -1, -2, -3, ....

ret1 = my_list[-2]

print(ret1)

# 定义一个空列表

# my_list = [] 或者 list()

# my_list = list()

# # 打印下元素个数

l = len(my_list)

print(l)

# 可以定义空的列表只要是列表那么就应该有[]

# 也支持下标索引获取元素

# 保存数据的元素可以是任意类型

总结:

* 列表就是一个容器, 它能够容纳各种数据类型, 表现形式是用 [] 包裹

* 列表中的元素可以重复, 并且是有顺序排列的, 我们可以通过下标索引的形式获取.

* 这里说的下标索引有从左向右的: 0, 1, 2, 3....

* 和从右往左的: -1, -2, -3, -4.....

* 我们定义空列表可以通过 [] 或者是 list()的形式来定义.

* 获取列表中元素长度

2. 列表的循环遍历

> 了更有效率的输出列表的每个数据，可以使用循环来完成

1) 使用for循环

namesList = ['xiaoWang', 123, 2323.23, True, False]

for name in namesList:

print(name)

结果:

xiaoWang

123

2323.23

True

False

2) 使用while循环

namesList = ['xiaoWang', 123, 2323.23, True, False]

length = len(namesList)

i = 0

while i<length:

print(namesList[i])

i+=1

结果:

xiaoWang

123

2323.23

True

False

3. 列表的相关操作

> 列表中存放的数据是可以进行修改的，比如"增"、"删"、"改""

1) 添加元素：append, extend, insert，列表可变，字符串不可变

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

append()方法语法：list.append(obj)

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

extend()方法语法：list.extend(seq)

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

insert()方法语法：list.insert(index, obj)

> - index -- 对象 obj 需要插入的索引位置。

> - obj -- 要插入列表中的对象。

# append:只要是python中的对象,都可以插入

my_list = ['12','23',23, 34]

my_list.append(2323)

print(my_list)

my_list.append(True)

print(my_list)

my_list.append("2323")

print(my_list)

my_list.append("12")

print(my_list)

my_list.append(3.134)

print(my_list)

my_list.append([23,'2323'])

print(my_list)

# extend:添加一个可以遍历的对象

my_list.extend([3,2,4,5,2])

print(my_list)

my_list.extend('hahhaha') # 列表中加入了h，a，h，h，a，h，a

print(my_list)

# my_list.extend(2323) # extend添加的对象需要可以遍历,这样写是错误的

# print(my_list)

# my_list.extend(True) # extend添加的对象需要可以遍历,这样写是错误的

# print(my_list)

my_list.extend("2323")

print(my_list)

my_list.extend("12")

print(my_list)

# my_list.extend(3.134) # extend添加的对象需要可以遍历,这样写是错误的

# print(my_list)

my_list.extend([23,'2323'])

print(my_list)

# insert 插入到制定位置

my_list1 = []

my_list1.insert(0,'hello')

print(my_list1)

总结

* append和extend给列表添加元素都是从列表的尾部添加, insert是在指定位置添加.

* append 添加的元素不限制类型, 任意对象都可以使用append加入列表

* extend加入列表的元素有限制: 只有能够遍历的对象才可以, 并且添加到列表的元素是对象遍历之后的每一小部分.

* 目前我们所学的能够遍历的对象只有: 字符串和列表 (后期还会有元组和字典)

* 列表加入元素的方式可以根据需求随意选择

2) 修改元素

> 修改元素的时候，要通过下标来确定要修改的是哪个元素，然后才能进行修改

# 定义一个列表

my_list = ['ab',23, 2.23]

# 获取

value = my_list[1]

print(value)

# 把获取的数据进行修改

my_list[1] = "22222"

print(my_list)

my_list[-1] = 223

print(my_list)

总结:

* 修改元素只需要遵循如下顺序: 先获取, 后修改

* 在列表中获取元素只需要根据下标索引值拿取.

* 修改时, 那刚刚拿取的元素重新赋值即可.

* 列表是可变的, 所以里面的元素也是可以修改的.

3) 查找元素

> 所谓的查找，就是看看指定的元素是否存在：in，not in ，index，count

> python中查找的常用方法为：

- in（存在）,如果存在那么结果为true，否则为false

- not in（不存在），如果不存在那么结果为true，否则false

> in的方法只要会用了，那么not in也是同样的用法，只不过not in判断的是不存在

# 查找元素(in, not in, index, count)

# 定义一个列表, 判断老李是否在列表中

str = '老李'

my_list = ['老李', '老张', '小明', 300, 300]

if str in my_list:

print('存在在列表中')

# 使用not in 判断一个元素不再列表中

if "小红" not in my_list:

print("小红不再列表中")

# index 通过index 获取某个元素在列表中的下表索引

ret1 = my_list.index(300)

print(ret1)

# count查找某个元素的值在列表中出现的次数

ret2 = my_list.count(300)

print(ret2)

# 查询4000 如果有给出下标索引值如果没有什么也不做

# count配合index实现:

count = my_list.count(300)

if count > 0:

index = my_list.index(300)

print(index)

# 使用in配合完成

if 300 in my_list:

index = my_list.index(300)

print(index)

总结:

* 查找元素一般使用 in 或者 not in 或者 index count结合

* in 或者 not in 我们搭配 if 语句来实现

* 如果单独使用 index 有崩溃的风险(index没有查找到元素的情况下,会崩溃)

* 要想使用index, 需要先判断元素在列表中的count值, 只有元素的个数大于等于1个, 代表列表中有此元素, 才可以用index进行下标值的获取, 这样比较安全, 排除了崩溃的可能.

* 我们这里不可以使用find 或者 rfind , 因为 find 和 rfind 是字符串常用的方法,我们这里说的是列表.

4) 删除元素

列表元素的常用删除方法有：

- del：根据下标进行删除, 也可以删除掉整个列表对象,提前释放内存

- pop：删除最后一个元素, 也可以删除单个指定元素把删除的元素返回回来

- remove：根据元素的值进行删除如果要删除的元素值不在列表,会崩溃

- clear: 清空这个列表把列表中的元素删除干净,但是列表还在

# 定义一个列表

my_list = ["小明", 20, "小红", 32]

# del 删除指定的元素(通过下标索引)

# 格式: del 列表名[下标索引]

# del 这个函数是python内置函数

del my_list[1:2]

print(my_list)

# del 第二种用法 ----> 了解 del my_list[:] 是不会报错的，del my_list会报错

# 提前杀死对象提前释放内存，print(my_list)会报错，my_list整个不存在了

del my_list

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

# pop是属于列表的方法

# pop 默认情况下会从列表的后面开始删除

# .pop() 会有一个返回值告知删除元素的值

print(my_list.pop())

print(my_list)

# pop(下标索引)

ret1 = my_list.pop(0)

print(ret1)

print(my_list)

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

# remove通过对象(数值)来删除列表中的元素，如果没有这样的元素，就会返回一个错误。
# 所以在remove之前，最好先count一下，看remove的元素是否在list里面

my_list.remove('小红')

print(my_list)

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

# clear 清空列表(列表中的所有元素全部删除)，移除列表中的所有项，等于del a[:]

my_list.clear()

print(my_list)

# clear() 等价于: my_list = [] 或者 my_list = list()

4、列表的排序

sort：对列表中的元素进行排序。

sort()方法语法：list.sort([func])

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

> - reverse：倒排列表中的元素。

# 排序, 默认是升序排列

my_list.sort()

# 降序排列

my_list.sort(reverse=True) 或者 my_list.reverse()

# python3.x中排序只支持数字类型

5、列表的嵌套

一个列表中的元素又是一个列表，那么这就是列表的嵌套。

# 需求: 一个学校有三个办公室现在有8为老师等待工位的分配

import random

# 定义一个学校

school = [[],[],[]]

# 定义一个变量保存8位老师，让8位老师站好等待随机分配办公室

my_str = 'ABCDEFGH'

for c in my_str:

# 产生随机数

index = random.randint(0,2)

school[index].append(c)

print(school)

# 获取元素和修改元素：

school[1][1] = 'F' # 这时候school中的元素已经修改了

6、求列表的最大最小值（冒泡排序）

my_list = [-1,-2,-3,-63,-20,-203]

# 定义一个变量,记录最大值

max = my_list[0]

for value in my_list:

if value > max:

max = value

print(max)

# 定义一个变量记录最小值

min = my_list[0]

for value in my_list:

if value < min:

min = value

print(min)

Python（1）—— 选择结构，循环结构，字符串和列表