一、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)