python notes基础系列

在 Python 中定义变量是 不需要指定类型（在其他很多高级语言中都需要）
数据类型可以分为 数字型 和 非数字型
数字型
- 整型 (int)
- 浮点型（float）
- 布尔型（bool）
  - 真 True 数学运算时表示 1
  - 假 False 数学运算时表示 0
- 复数型 (complex)，基本不用
  - 主要用于科学计算，例如：平面场问题、波动问题、电感电容等问题
非数字型
- 字符串（str）用''
- 列表
- 元组
- 字典

示例：

查看变量类型： type函数

示例：

输入：

print(type(heigth))

输出：

<class 'float'>

1.2.4.变量的计算

数字型变量之间可以直接计算
- 如果变量是bool型，在计算时
  - True 对应的数字是 1
  - False 对应的数字是 0

字符串变量 之间使用 + 拼接字符
字符串变量 可以和整数使用 * 重复拼接相同的字符串

str= "-" * 50
print(str)

输出结果：

'--------------------------------------------------'

数字型变量 和 字符串 之间 不能进行其他计算

输入：

first_name = "zhang"

x = 10

print(x + first_name)

输出：

TypeError: unsupported operand type(s) for +: 'int' and 'str' 类型错误：+ 不支持的操作类型：int 和 str

1.2.5 变量的命名

标识符
- 标示符就是程序员定义的 变量名、函数名
- 标示符可以由字母、下划线 和数字组成
关键字

判断是否为关键字

print(keyword.iskeyword(''))

查找关键字

print(keyword.kwlist)

标识符命名规则
- 标识符 是 区分大小写
- 在定义变量时，= 的左右应该各保留一个空格
- 如果变量名需要由二个或多个单词组成时，可以按照以下方式命名
  - 每个单词都使用小写字母
  - 单词与单词之间使用 _下划线 连接。例如：first_name、last_name、qq_number、qq_password
  - ！！！不能以数字开头，不能与关键字同名，应尽量避免与引用到的函数或库同名
  - 驼峰命名
    - 第一个单词以小写字母开始，后续单词的首字母大写。例如：firstName、lastName 【推荐】
    - 第一个单词以及后面每一个单词的首字母都采用大写字母。例如：FirstName、LastName、CamelCase

1.2.6.输入和输出

输入函数input
- 字符串变量 = input( 输入信息)，之后输入信息，按 enter，才会print！！！

示例：

输入：

# 1. 输入苹果单价
price_str = input("请输入苹果价格：")

# 2. 要求苹果重量
weight_str = input("请输入苹果重量：")

# 3. 计算金额
# 1> 将苹果单价转换成小数
price = float(price_str)

# 2> 将苹果重量转换成小数
weight = float(weight_str)

# 3> 计算付款金额
money = price * weight

print(money)

输出：

请输入苹果价格：5
请输入苹果重量：3
15.0

类型转换函数
- int(x) 转整数 x为小数，【不能转为int】
- float(x) 转浮点数，【即使x为整数，也可以转为float】
input 函数与类型转换函数同时使用
- 如：

price = float(input("请输入价格:"))

格式化输出
- 如果希望输出文字信息的同时，一起输出 数据，就需要使用到 格式化操作符% 被称为格式化操作符，专门用于处理字符串中的格式
  - %和不同的字符连用
  - % 是起着占位符的作用
语法格式如下，格式化字符串里面有 % 的地方就是对后面的变量进行占位

print("格式化字符串" % 变量1)

print("格式化字符串" % (变量1, 变量2...))

print("含格式转换后的数字的字符串" % (变量名1，变量名2))

常用格式化字符	含义
%s	字符串
%d	有符号十进制整数，`%06d` 表示输出的整数显示位数，不足用0补齐不足的地方使用 `0` 补全，%-6d 是6个位置的左对齐，%6d是位置右对齐
%f	浮点数，`%.2f` 表示小数点后只显示两位
%%	输出 `%，加在数字后面`

示例：

输入：

student_no = 21
name = 'broccoli'
price = 20.56
weight = 5.23
money = price * weight
scale = 0.04356
print("我叫 %s，请多多关照！" % name)
print("我的工号是 %0d" % student_no)
print("橙子单价 %.02f 元／斤，购买 %.02f 斤，需要支付 %.02f 元" % (price, weight, money))
print('0.0435的百分数形式为 %.02f%%' % (scale * 100))

输出

我叫 broccoli，请多多关照！
我的工号是 21
橙子单价 20.56 元／斤，购买 5.23 斤，需要支付 107.53 元
0.0435的百分数形式为 4.36%

Process finished with exit code 0

2.day02条件语句

2.1.条件语句 -【程序流程之一：分支】

2.1.2.if ...[一种结果]

if 要判断的条件:
    条件成立时，要做的事情

2.1.2.if ...else...[两种结果]

if 要判断的条件:
    条件成立时，要做的事情
else:
    条件不成立时，要做的事情

代码的缩进为一个 tab 键，或者 4 个空格（自动缩进）

2.1.3.if ...elif...【三结果以上】

if 条件1:
    条件1满足执行的代码
    ……
elif 条件2:
    条件2满足时，执行的代码
    ……
elif 条件3:
    条件3满足时，执行的代码
    ……
else:
    以上条件都不满足时，执行的代码
    ……

可以用or 替换elif

if (条件1) or (条件2) or (条件3) or ...:

    条件1满足执行的代码

else:
    以上条件都不满足时，执行的代码

2.1.4.if嵌套

if 条件 1:
    条件 1 满足执行的代码
    ……

    if 条件 1 基础上的条件 2:
        条件 2 满足时，执行的代码
        ……    

    # 条件 2 不满足的处理
    else:
        条件 2 不满足时，执行的代码

# 条件 1 不满足的处理
else:
    条件1 不满足时，执行的代码
    ……

示例：

# 定义布尔型变量 has_ticket 表示是否有车票
has_ticket = True

# 定义整数型变量 knife_length 表示刀的长度，单位：厘米
knife_length = 20

# 首先检查是否有车票，如果有，才允许进行 安检
if has_ticket:
    print("有车票，可以开始安检...")

    # 安检时，需要检查刀的长度，判断是否超过 20 厘米
    # 如果超过 20 厘米，提示刀的长度，不允许上车
    if knife_length >= 20:
        print("不允许携带 %d 厘米长的刀上车" % knife_length)
    # 如果不超过 20 厘米，安检通过
    else:
        print("安检通过，祝您旅途愉快……")

# 如果没有车票，不允许进门
else:
    print("大哥，您要先买票啊")

2.1.5 随机数的处理【游戏案例】

随机生成一定范围内的整数使用 random 的模块——工具包

import random

导入模块后，可以直接在 模块名称 后面敲一个 . 然后按 Tab 键，会提示该模块中包含的所有函数
random.randint(a, b) ，返回 [a, b] 之间的整数，包含 a 和 b
例如：

random.randint(12, 20)  # 生成的随机数n: 12 <= n <= 20   
random.randint(20, 20)  # 结果永远是 20   
random.randint(20, 10)  # 该语句是错误的，下限必须小于上限

2.2.逻辑运算符

2.2.1.算数运算符

是完成基本的算术运算使用的符号，用来处理四则运算

运算符	描述	实例
+	加	10 + 20 = 30
-	减	10 - 20 = -10
*	乘	10 * 20 = 200
/	除	10 / 20 = 0.5
//	取整除	返回除法的整数部分（商） 9 // 2 输出结果 4
%	取余数	返回除法的余数 9 % 2 = 1
**	幂	又称次方、乘方，2 ** 3 = 8

在 Python 中 * 运算符还可以用于字符串，计算结果就是字符串重复指定次数的结果

str=("-" * 50)
print(str)

输出结果：

'----------------------------------------'

2.2.2.比较（关系）运算符

运算符	描述
==	检查两个操作数的值是否相等，如果是，则条件成立，返回 True
!=	检查两个操作数的值是否不相等，如果是，则条件成立，返回 True
>	检查左操作数的值是否大于右操作数的值，如果是，则条件成立，返回 True
<	检查左操作数的值是否小于右操作数的值，如果是，则条件成立，返回 True
>=	检查左操作数的值是否大于或等于右操作数的值，如果是，则条件成立，返回 True
<=	检查左操作数的值是否小于或等于右操作数的值，如果是，则条件成立，返回 True

Python 2.x 中判断 不等于 还可以使用 <> 运算符

!= 在 Python 2.x 中同样可以用来判断 不等于

2.2.3.逻辑运算符

运算符	逻辑表达式	描述
and	x and y	只有 x 和 y 的值都为 True，才会返回 True 否则只要 x 或者 y 有一个值为 False，就返回 False
or	x or y	只要 x 或者 y 有一个值为 True，就返回 True 只有 x 和 y 的值都为 False，才会返回 False
not	not x	如果 x 为 True，返回 False 如果 x 为 False，返回 True

not 的示例：

# 定义一个布尔型变量 `is_employee`，编写代码判断是否是本学校学生
is_studnt= True

# 如果不是提示不允许入内
if not is_studnt:
    print("不得进入本校园")

3.day03循环语句

3.1.while循环语句 -【程序流程之一：循环】

3.1.1.基本while语句（循环中的重复）

使用while重复显示相同内容的示例：

# 定义变量的初始值
i = 1
# 循环语句
while i<=5: # 限定变量执行的条件（次数）
    print('今天终于可以吃土司啦') # 要重复执行的事情
# 修改变量（赋值运算）
    i+=1

输出：

今天终于可以吃土司啦
今天终于可以吃土司啦
今天终于可以吃土司啦
今天终于可以吃土司啦
今天终于可以吃土司啦

注意：

while 语句中的缩进部分是一个 独立的代码块。 如，while中插入条件语句if，则if是独立的。

3.1.2赋值运算

注意：赋值运算符中间不能使用空格

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	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

3.1.3.计数方法

自然计数法（从 1 开始）—— 更符合人类的习惯
程序计数法（从 0 开始）—— 几乎所有的程序语言都选择从 0 开始计数

3.1.4.循环中的计算

累加1-100数值，输出sum为例：

# 1-100累加
# 先定义变量的初始值
i = 0
sum=0
# 循环语句
while i<=100: # 限定变量执行的条件
    sum=sum+i # 要做的事情
# 修改变量 （赋值运算）
    i+=1
print("1-100的累加值=%d"%sum)

输出：

1-100的累加值=5050

3.1.5.循环中插入if语句

累加1-100的偶数，输出sum为例：

# 先定义变量的初始值
i = 0
sum=0
# 循环语句
while i<=100: # 限定变量执行的条件
    if i % 2 == 0 :  # 条件语句
        sum=sum+i    # 要做的事情
# 修改变量  （赋值运算）
    i+=1
print("1-100的偶数累加值=%d"%sum)

输出：

1-100的偶数累加值=2550

注意：有if条件语句时，赋值运算 i+=1要放在if代码段中，而不是while语句中，因为i=+1是满足if条件的数值。

3.1.6. `break` 和 `continue`

break 和 continue 是专门在循环中使用的关键字
- break：某一条件满足时，不再执行循环体中后续重复的代码，并退出循环

# break
# 某一条件满足时，不再执行循环体中后续重复的代码，并退出循环
i=0
while i<5:
    if i==3:
        break
    print(i)
    i+=1

print("end")

输出：

0
1
2
end

某一条件满足时，不再执行本次循环体中后续重复的代码，但进入下一次循环判断

# continue
i=0
while i<5:
    if i==3:
        i+=1 # ’下一次循环‘使用continue前需要改变量
        continue  # 不执行后续代码，但执行’下一次循环‘
    print(i)
    i+=1

print("end")

输出：

0
1
2
4
end

3.2.while循环嵌套

初级用法：while循环嵌套示例：求5行*的形状

i=1
while i<=5 :
    m=1
    while m<=i:
        print("*",end="") # end=""相当于不留空格
        m+=1
    print() # 换行
    i+=1

高级用法：使用公式： "拼接符号"*数量

i=1
while i<=5 :
    print("*"*i)
    i+=1

输出：

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

3.3综合运用

综合运用 while基本语句 while嵌套 if语句 break 的示例：打印乘法表

# 应用 打印乘法表

i=1
while i<=9 :
    m=1
    while m<=i:
        if i==3 :
            break
        print(("%d * %d = %d"%(m,i,m*i)),end="  ")
        m+=1
    print()
    i+=1

输出：

1 * 1 = 1  
1 * 2 = 2  2 * 2 = 4  

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

4.day04 非数字型的特殊变量类型

4.1列表（数组）

4.1.1. 定义

List（列表）是 Python 中使用 最频繁 的数据类型，在其他语言中通常叫做数组

列表专门用于存储 一串信息（数字、英文、符号）
列表用 [] 定义，数据之间使用 , 分隔
列表的索引从0开始
- 索引就是数据在列表中的位置编号，索引又可以被称为下标
定义：list=[，，，] 如：[1, 'bobo_', '123']
类型：<class 'list'>

4.1.2.列表常用操作（增删改查排）

说明：x为索引，a为元素

序号	分类	关键字 / 函数 / 方法	说明
1	增加	list.insert(x,'a')	在x处的索引增加‘a’元素或列表或元祖，在原有位置增加，之后会依次顺位；如果超出位置不会报错，会在末尾增加。
		list.append('a')	在末位增加一个元素，或增加一个列表[] （仅占一个索引位置）
		list.extend([a,'b','c'])	在末尾增加列表（可迭代对象），（可多个元素，占多个索引位置）
2	删除	del list[x]	删除索引X的元素
		list.remove(a)	删除a元素 --若存在多个，只删除第一次出现的元素
		list.pop(x)	删除指定索引x的元素，不指定，默认是最后一个索引。返回被删除的元素
		list.clear()	清空列表，但列表还在
3	修改	list[x]=a	修改指定索引的数据，数据不存在会报错
4	查询	list[x]	根据索引查元素，索引不存在会报错
		list.index(a)	根据内容查所在索引。不在列表中，会报错
		list.index(a,x,y)	根据内容和制定索引范围，查所在索引
		list.count(a)	查元素出现的次数
		len(list)	查列表的索引个数
		if a in list	检查表中是否包含某元素
5	排序	list.sort()	升序排序
		list.sort(key=int)	转换为整型后排序
		list.sort(reverse=True)	降序排序
		list.reverse()	逆序、反转

4.1.3.关键字、函数和方法（科普）

关键字 是 Python 内置的、具有特殊意义的标识符

import keyword
print(keyword.kwlist)
print(len(keyword.kwlist))

输出结果：

['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'] 35

关键字后面不需要使用括号

函数封装了独立功能，可以直接调用

函数名(参数)

函数需要死记硬背，方法需要对象类调用，后面会详细学习到

方法和函数类似，同样是封装了独立的功能
方法需要通过对象来调用，表示针对这个对象要做的操作

对象.方法名(参数)

在变量后面输入 .，然后选择针对这个变量要执行的操作，记忆起来比函数要简单很多

4.1.4. 循环遍历

遍历就是 从头到尾 依次从列表中取出 每一个元素，并执行相同的操作
实现遍历的方式，比如while循环、for循环、迭代器等

# while循环实现列表的遍历：打印出列表的所有元素，i 是起到循环得到索引值的作用
i = 0
name_list = ["zhangsan", "lisi", "wangwu"]
list_count = len(name_list)
while i < list_count:
    name = name_list[i]
    print(name)
    i += 1

for 循环其实就是专门用来对高级变量进行循环遍历的（如后面的元组、字典）
高级变量的定义与for循环同一层级！（同一代码块）
for循环的本质是 迭代器

# for 实现列表的遍历
# 列表循环的本质就是对列表的每一个元素获取值，即每次循环都会取出一个列表的值给变量name，当元素全部取出后，循环就结束了
for name in name_list:
    循环内部针对列表元素进行操作
    print(name)

应用：使用range函数快捷循环创建列表
- 1.基本的方式

# range语法：range(start, stop, step)
a=[x for x in range(4)]
b=[x for x in range(1,7)]
c=[x for x in range(1,7,2)]

print(a)
print(b)
print(c)

输出结果：

[0, 1, 2, 3] [1, 2, 3, 4, 5, 6] [1, 3, 5]

2. 在循环的过程中使用if

a=[x for x in range(1,7) if x%2==0]
b=[x for x in range(1,7) if x%2!=0]
c=[x for x in range(1,7,2)]

print(a)
print(b)
print(c)

输出结果：

[2, 4, 6] [1, 3, 5] [1, 3, 5]

3. 2个for循环（创建由元祖组成的列表）

d=[(x,y) for x in range(1,4) for y in range(3,5)]

输出结果：

[(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]

4.1.5.列表嵌套

类似while循环的嵌套，列表也是支持嵌套的，也就是多维列表

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

schoolNames = [['北京大学','清华大学'],
                ['南开大学','天津大学','天津师范大学'],
                ['山东大学','中国海洋大学']]

应用（有点难）：一个学校，有3个办公室，现在有8位老师等待工位的分配，请编写程序，完成随机的分配，假设每个教室可以容纳任意数量的教师

import random

# 定义一个列表用来保存3个办公室
offices = [[],[],[]]

# 定义一个列表用来存储8位老师的名字
names = ['A','B','C','D','E','F','G','H']

# 分配程序：
i = 0
for name in names:
    index = random.randint(0,2)    
    offices[index].append(name)


# 打印分配的结果：
i = 1
for tempNames in offices:
    print('办公室%d的人数为:%d'%(i,len(tempNames)))
    i+=1
    for name in tempNames:
        print("%s"%name,end='')
    print("\n")
    print("-"*20)

4.1.7.应用场景

尽管 Python 的列表中可以 存储不同类型的数据
但是在开发中，更多的应用场景是
1. 列表一般只存储相同类型的数据
2. 通过 for循环，在循环体内部，针对列表中的每一项元素，执行相同的操作

4.2元祖

4.2.1.定义

Tuple

（元组）与列表类似一个用 [] 一个用 () 定义，不同之处在于元组的元素不能修改
- 元组表示多个元素组成的序列
- 元组在 Python 开发中，有特定的应用场景
用于存储 一串信息，数据之间使用 , 分隔
元组用 () 定义
元组的索引从0开始
- 索引就是数据在元组中的位置编号

4.2.2.元祖常用操作（仅查询）

列表VS元祖常用操作对比表

4.2.3.循环遍历

取值就是从元组中获取存储在指定位置的数据
遍历就是 从头到尾 依次从元组中获取数据

# for 循环内部使用的变量 in 元组
for item in info:
    循环内部针对元组元素进行操作
    print(item)

在 Python 中，可以使用 for 循环遍历所有非数字型类型的变量：列表、元组、字典以及 字符串
提示：在实际开发中，除非 能够确认元组中的数据类型，否则针对元组的循环遍历需求并不是很多

4.2.4.应用场景

作为函数的参数和返回值。一个函数可以接收 任意多个参数，或者 一次返回多个数据
格式字符串，格式化字符串后面的 () 本质上就是一个元组

info = ("zhangsan", 18)
info_str="%s 的年龄是 %d" % info
# 注意从这里可以发现，格式化字符串不依赖于 print 函数，它就是一个带格式化符号的字符串而已
print(info_str)

输出结果：

zhangsan 的年龄是 18

让列表不可以被修改，以保护数据安全。
自动组包的默认类型：组包后是一个元组，可以用来快速交换两个变量的值

a=3
b=4
# 赋值的右侧有多个数据时，会自动组包成元组
# 如果赋值的左侧接收的变量和右侧的变量的个数一致，就会自动解包，一一对应赋值
b,a=a,b
# 注意：右侧组包后相当于是变成了一个元组
# b,a=(a,b)
print(a)
print(b)

# 如果个数不一致左边就得到一个元组
c=a,b
print(c)
print(type(c))

输出结果：

4 3 (4, 3)

元组和列表之间的转换
使用 list 函数可以把元组转换成列表

list(元组)

使用 tuple 函数可以把列表转换成元组

tuple(列表)

4.3字典

4.3.1.定义

字典用 {key:value，...} 定义
字典使用键值对(key、value对)存储数据，键值对之间使用,分隔
- 键 key 是索引：注意索引不再是 0，1，2... 了，虽然可以用数字，但是一般使用字符串
- 值 value 是数据
- 键和值之间使用 : 分隔
- 键必须是唯一的：如果有多个，后者会覆盖前者
- 值可以取任何数据类型，但键只能使用 字符串、数字或元组

xiaoming = {"name": "小明",
            "age": 18,
            "gender": True,
            "height": 1.75}

dictionary（字典）是 除列表以外 Python 之中 最灵活 的数据类型
字典同样可以用来存储多个数据
- 通常用于存储 描述一个物体的相关信息
和列表的区别
- 列表是有序的对象集合
- 字典是无序的对象集合

4.3.2.字典常用操作

序号	分类	关键字 / 函数 / 方法	说明
1	增加	字典[键] = 数据	键不存在，会添加键值对；键存在，会修改键值对的值
2	删除	del 字典[键]	删除指定的键值对
		字典.pop(键)	删除指定键值对,返回被删除的值
		字典.clear	清空字典
3	修改	字典[键] = 数据	键不存在，会添加键值对；键存在，会修改键值对的值
		字典.setdefault(键，数据)	键值对不存在，添加键值对；存在则不做处理
		字典.update(字典2)	取出字典2的键值对，键值对不存在，添加键值对；存在则修改值
4	查询	字典[键]	根据键取值，键值对不存在会报错
		字典.get(键)	根据键取值，键值对不存在不会报错
		字典.keys()	可进行遍历，获取所有键
		字典.values()	可进行遍历，获取所有值
		字典.items()	可进行遍历，获取所有(键，值)

4.3.3.for ...in ... 循环遍历

遍历就是依次从字典中获取所有键值对

# for 循环内部使用的 `key 的变量` in 字典
for k in xiaoming:

    print("%s: %s" % (k, xiaoming[k]))

提示：在实际开发中，由于字典中每一个键值对保存数据的类型是不同的，所以针对字典的循环遍历需求并不是很多

4.3.4.应用场景

尽管可以使用 for in 遍历字典
但是在开发中，更多的应用场景是：
- 使用 多个键值对，存储 描述一个物体的相关信息 —— 描述更复杂的数据信息
- 将 多个字典 放在 一个列表 中，再进行遍历，在循环体内部针对每一个字典进行 相同的处理

card_list = [{"name": "张三",
              "qq": "12345",
              "phone": "110"},
             {"name": "李四",
              "qq": "54321",
              "phone": "10086"}
             ]

4.4字符串

4.4.1.定义

字符串 就是 一串字符，是编程语言中表示文本的数据类型
在 Python 中可以使用一对双引号"或者一对单引号'定义一个字符串
- 虽然可以使用\\"或者\\'做字符串的转义，但是在实际开发中：
  - 如果字符串内部需要使用 "，可以使用 ' 定义字符串
  - 如果字符串内部需要使用 '，可以使用 " 定义字符串
可以使用索引获取一个字符串中 指定位置的字符，索引计数从 0 开始
也可以使用 for 循环遍历 字符串中每一个字符

大多数编程语言都是用 " 来定义字符串

string = "Hello Python"

for c in string:
    print(c)

4.4.2. 字符串的常用操作

1) 判断

方法	说明
string.isalpha()	如果 string 至少有一个字符并且所有字符都是字母则返回 True
string.isdecimal()	如果 string 只包含数字则返回 True
string.islower()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True
string.isupper()	如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True
string.startswith(str)	检查字符串是否是以 str 开头，是则返回 True
string.endswith(str)	检查字符串是否是以 str 结束，是则返回 True

2) 查找和替换

方法	说明
string.find(str, start=0, end=len(string))	检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 `-1`
string.rfind(str, start=0, end=len(string))	类似于 find()，不过是从右边开始查找
string.index(str, start=0, end=len(string))	跟 find() 方法类似，不过如果 str 不在 string 会报错
string.rindex(str, start=0, end=len(string))	类似于 index()，不过是从右边开始
string.replace(old_str, new_str, num=string.count(old))	返回一个新字符串，把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次

3) 拆分和连接

方法	说明
string.partition(str)	返回元组，把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面)
string.rpartition(str)	类似于 partition() 方法，不过是从右边开始查找
string.split(str="", num)	返回列表，以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 '\r', '\t', '\n' 和空格
string.splitlines()	返回列表，按照行('\r', '\n', '\r\n')分隔
string1 + string2	拼接两个字符串
string.join(seq)	返回字符串，以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串

4) 大小写转换

方法	说明
string.lower()	返回新字符串，转换 string 中所有大写字符为小写
string.upper()	返回新字符串，转换 string 中的小写字母为大写

5) 文本对齐

方法	说明
string.ljust(width)	返回新字符串，基于原字符串左对齐，并使用空格填充至长度 width
string.rjust(width)	返回新字符串，基于原字符串右对齐，并使用空格填充至长度 width
string.center(width)	返回新字符串，基于原字符串居中，并使用空格填充至长度 width

6) 去除空白字符

方法	说明
string.lstrip()	返回新字符串，截掉 string 左边（开始）的空白字符
string.rstrip()	返回新字符串，截掉 string 右边（末尾）的空白字符
string.strip()	返回新字符串，截掉 string 左右两边的空白字符

提示：列表除了查询方法和pop方法都没有返回值，字符串所有方法都有返回值

4.4.3.字符串的切片

切片译自英文单词 slice，翻译成另一个解释更好理解: 一部分
切片使用 索引值 来限定范围，根据步长从原序列中 取出一部分 元素组成新序列
切片方法适用于 字符串、列表、元组

字符串[开始索引:结束索引:步长]

注意：

指定的区间属于左闭右开型 [开始索引, 结束索引) 对应

开始索引 <= 范围 < 结束索引
- 从 起始 位开始，到 结束位的前一位 结束（不包含结束位本身)
从头开始，开始索引 数字可以省略，冒号不能省略
到末尾结束，结束索引 数字和冒号都可以省略
步长默认为 1，如果元素连续，数字和冒号都可以省略

索引的顺序和倒序

在 Python 中不仅支持 顺序索引，同时还支持 倒序索引
所谓倒序索引就是从右向左计算索引
- 最右边的索引值是 -1，依次递减
注意：如果步长为负数,
- 并省略了开始索引，则开始索引表示最后一位
- 并省略了结束索引，则结束索引表示第一位

5.day05 函数

5.1.函数的概念

所谓函数，就是把 具有独立功能的代码块 组织为一个整体，在需要的时候调用
函数的使用包含两个步骤：
1. 定义函数 —— 在函数中编写代码，实现功能
2. 调用函数 —— 执行编写的代码
函数的作用，在开发程序时，使用函数可以提高编写的效率以及代码的重用

5.2.函数的使用步骤

def 函数名(): #定义函数
    """求和 1+2"""    #函数的注释（点击函数名后，ctrl+q） 

    函数封装的代码  #封装函数
    ……

函数名() #调用函数

5.3.函数的参数

在函数名的后面的小括号内部填写参数
多个参数之间使用 , 分隔
种类：定义函数中的参数为形式参数；调用函数中的参数为实际参数

def sum_2_num(num1, num2): #定义函数中的参数为形式参数

    result = num1 + num2

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

sum_2_num(50, 20) # 调用函数中的参数为实际参数

5.4.函数的返回值

返回值是接收函数的执行结果，并通过print返回。
格式：return 无参数值或参数值的运算

def sum_2_num(num1, num2):
    sum = num1*num2
    return sum
# # 调用函数，并使用 result 变量接收计算结果
res=sum_2_num(10,20)
print(res)

如果不使用返回值，则需要在函数中print（）执行的结果

def sum_2_num(num1, num2):
    sum = num1*num2
    print(sum)
# # 调用函数
sum_2_num(10, 20)

5.5.函数嵌套

def print_line(char, length): #函数1：打印一条由length个字符char组成的线

    print(char * length)


def print_lines(char, length): #函数2：打印5条由length个字符char组成的线

    row = 0

    while row < 5:
        print_line(char, length) #函数1的结果

        row += 1

print_lines("&",20) #调用函数2

5.6.匿名函数

5.6.1.定义

匿名函数没有名字，使用Lambda关键字来表达函数，形式如下：

lambda [arg1 [,arg2,.....argn]]:expression

调用匿名函数需要用接收变量

res=lambda x,y:x+y
print(res(1,2))

应用：嵌套匿名函数

# 定义一个函数
def fun(a, b, opt):
     print("a = %s" % a)
     print("b = %s" % b)
     print("result =%s" % opt(a, b))

# 调用函数
fun(1, 2, lambda x,y:x+y)
输出结果：

a = 1 b = 2 result = 3

应用：创建列表（结合列表推导式）

使用匿名函数


res2=(lambda n:[i**2 for i in range(1,n+1)])(4)
print(res2)

输出：[1, 4, 9, 16]

使用普通函数

def func(n):
    list=[]
    for i in range(1,n+1):
        list.append(i**2)
    return list
res=func(4)
print(res)

输出：[1, 4, 9, 16]

6.day06模块

6.1.模块的定义

模块就好比是 工具包，要想使用这个工具包中的工具，就需要 导入 import 这个模块
每一个以扩展名 py 结尾的 Python 源代码文件都是一个模块
在模块中定义的 全局变量 、函数都是模块能够提供给外界直接使用的工具
是一个标示符，可以由字母、下划线 和数字组成，不能以数字开头，不能与关键字重名

6.2.导入模块

新建 model.py，定义变量或者函数。代码如下：

str= "father"

def f():
    print('model_f')

再新建 getmodel.py 文件，导入模块，并且编写以下代码：

import model

print(model.str)
mode.f()

7.day7高级函数

7.1.函数内修改全局变量

a = 10

def test():
    global a
    a = 5  # 修改全局变量
    print("函数内a：%d" %a)

test()
print("函数外a：%d" %a)

输出：

函数内a：5
函数外a：5

7.2.函数返回值

7.2.1.返回多个值（结合组包）

# 返回多个值
def func2():
    return 1, 1.5

a = func2() # 用一个接收多个返回值，组包 。
print(a) # 形式：（，）
print(a[0]) # 取元祖的第1个索引
a, b = func2() # 用对应数量接收对应数量的返回值，拆包。
print(a,b) # 形式：无（）

a, b, c = 1, 1.5, "hello"
print(a,b,c)

7.2.2.多个返回值（结合if）

def is_even_num(num):
    """判断奇偶数"""
    if num % 2 == 0:
        return True
    else:
        return False

7.3.函数参数

7.3.1.默认参数

形参设定默认值称为 默认参数
调用函数时，如果没有传入默认参数对应的实参，则实参使用默认值。

def printinfo(name, age = 35):
   # 打印任何传入的字符串
   print("Name: %s", % name)
   print("Age: %s", % age)

# 调用printinfo函数
printinfo("miki")
printinfo("miki", 20)

注意：默认参数一定要位于参数列表的最后面。

>>> def printinfo(name, age=35, sex):
...     print name
...
  File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

7.3.2.关键字参数

调用函数时，实参可以指定对应的形参，称为 关键字参数

关键字参数一旦使用，所有实参都要使用，除非该实参对应的是可变参数

def printinfo(name, age):
   # 打印任何传入的字符串
   print("Name: %s", % name)
   print("Age: %s", % age)

printinfo(age=9,name="miki" )

7.3.3. 可变参数

args
- 函数可以定义 可变参数，用于接收任意数量的参数
- 可变参数的前边需要添加*，用于提示python解释器该参数为可变参数
- 使用可变参数直接用args即可（不需要加*）
- 可变参数的本质是 将传递的参数包装成了元组

def sum_num(a, b, *args):  

    result = a + b
    for temp in args:
        result += temp
    print(a)
    print(b)
    print(args)

    return result

res=sum_num(1,2, 3, 4,5,6)
print(res)

输出：

1
2
(3, 4, 5, 6)
21

kwargs
- 可变参数还有一种形式 可以接收不存在的关键字参数
- 定义参数时需要在变量名前添加两个*
- 这种可变参数会将 不存在的关键字参数包装成字典

def sum_num(a, b, **kwargs):
    print(a)
    print(b)
    print(kwargs)
sum_num(a=1, b=2,c="你好",d="好久不见")

输出：

1
2
{'c': '你好', 'd': '好久不见'}

qq_52360873

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
python notes基础系列

目录1.day011.1. 算数运算符1.day011.1.算数运算符运算符描述优先级 + 加 3 - 减 3 * 乘或重复效果 2 ** 幂/次方 1 / 除 2 // 取整除 2 % 取余数 2 * 与str 结合示例：str="-" * 50print(str)输出结果：'-----------------...
复制链接

扫一扫