第二周整理笔记

Python基础

1.Python基本数据类型

• 列表（list）：存储多个数据，能方便获取整体或者局部

  • 中括号括起来，内存可以存放多个数据值，数据值之间逗号隔开（数据值可以使任意类型）
  • l1 = [1, 2, 3]
  • 索引取值：在IT领域数字的起始位置通常是从0开始 现实生活中是从1开始

• 字典(dict)：存储多个数据，能够方便的获取整体或者局部，数据具有对于解释

  • 描述：大括号括起来，内部可以存放多个数据 数据的组织形式是K:V键值对（K是对V的描述性性质的信息，一般是字符串；V是真实的数据值，可以是任意数据类型）
  • 字典取值：字典无法使用索引取值(因为字典是无序的)，可以使用按K取值

按K取值
info_dict = {'姓名': 'Tony', '年龄': 18, '爱好': 'read'}
print(info_dict['姓名'])  # Tony
print(info_dict['年龄'])  # 18
print(info_dict['家产'])  # K不存在直接报错

• 布尔值(bool)：用来表示事物是否可行、是否正确、是否合理（总共就两个值）

  • is_right = True # 真 可以 正确
  • is_delete = False # 假 不可以 错误
  • 布尔值在程序中是最多、使用频率最高的，存储布尔值的名字一般使用is开头，程序中所有的数据类型都可以转成布尔值
  • 布尔值为False的数据：0 None 空字符串 空列表 空字典， 除这些之外所有的数据对于的布尔值都是True

• 元组(tuple)：存储多个数据，能方便获取整体或者局部，与列表的区别在于元组内数据值不能"直接修改" 而列表可以

  • 作用：一般用于存储一些只能看不能改的数据
  • 描述：小括号括起来 内存可以存放多个数据值 数据值与数据值之间逗号隔开（数据值可以是任意数据类型）
  • 基本使用：t1 = (1, 2, 3)

• 集合(set)：集合只用于去重和关系运算

  • 去重：自动去除重复的数据
  • 关系运算：判断两个集合之间数据的关系
  • 基本使用：s1 = {1, 2, 3, 4}
  • 定义空集合：必须使用关键字才能定义空集合

1 = {}
s1 = {}
print(type(d1))  # dict
print(type(s1))  # dict
ss = set()  # 必须使用关键字才能定义空集合
print(type(ss))

用户交互

• 输入：向计算机传递信息
  1. 先获取用户输入的数据
  2. 再赋值给左边的name
  3. 然后通过name反复使用用户输入的数据

input()  # 获取用户输入
name = input('请输入用户名:')

• 输出：计算机向外界输出信息
  • 打印数据值(括号内可以直接放数据值，也可以一次性打印多个值)

print()

格式化输出

• 在python中占位，需要使用占位符
  • %s: 支持所有数据类型替换 (使用最多)
  • %d: 只支持给数字占位

基本运算符

• 算术运算符

+ 加
- 减
* 乘
/ 除
// 整除
% 取模
**(次方) 幂指数

• 比较运算符

== 等于
!= 不等于

• 逻辑运算符

  • and 与：链接的多个条件必须都成立结果才成立(True)
    • 连接的条件：如果不是一个具体的值，则需要自动转换成布尔值
    • 如果所有的连接符号都是and，只要有一个不符合，后面结果肯定不成立
    • 由于and前面的运算得出的布尔值是True，所以and连接的条件最终的结果取决于后面的
    • 如果后面的值是明确的数据值 那么直接返回该数据值(数据值对应的布尔值必须是True)
  • or 或：链接的多个条件有一个成立结果就成立(True)
    • 如果所有的连接符号都是or，只要有一个符合 后面结果肯定成立
  • not 非：将条件取反(原本是对的就变成错的，如果是错的就变成对的)
  • 三者混合使用，有优先级，如果需要三者混合使用，那么应该加上括号来区别优先级
  • and和or连接的多个条件在返回具体结果的时候可能是布尔值也可能是数据值
  • 我们在日常写代码的时候不需要纠结具体返回的是什么，直接当成布尔值处理

• 成员运算符

  • in 在什么什么之内
  • not in 不在什么什么之内
  • 列表在做成员运算的时候最小单位是数据值整体，不能再拆分也不能合并
  • 字符串在做成员运算的时候最小单位是单个字符，也可以增加字符个数
  • 字典在做成员运算的时候只有K会参与运算，V默认不暴露给外界

• 身份运算符

  • is 判断数据值的内存地址是否一致(火眼金睛)
  • == 判断数据值得值是否一致 地址无所谓
  • id() 该方法会返回一串数字 相当于内存地址
  • 值相等，内存地址可能不等
  • 内存地址相等，值肯定相等(单次程序中）

• 变种情况

x = x + 1 # x += 1
x = x - 1 # x -= 1
x = x * 1 # x *= 1
x = x / 1 # x /= 1

多种赋值符号

• 链式赋值

x = 1
y = x
x = z
x = y = z = 1

• 解压赋值：赋值符号的左边至少有两个及以上的名字
  • 左边的名字和右边的数据值，个数一致
  • 当带解压的数据非常多，在解压赋值的时候会自动将多余的数据值组织成列表赋值给*号后面的变量名

l1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
a, b, *c, d = l1
print(a)  # 1
print(b)  # 2
print(c)  # [3, 4, 5, 6, 7, 8]
print(d)  # 9

流程控制

• 流程控制：事物的执行流程
• 事务执行流程：
  • 顺序结构：从上往下依次执行
  • 分支结构：根据条件的不同执行不同的代码
  • 循环结构：根据条件判断是否一直做某件事

2.分支结构

• 基本使用：需要使用关键字if编写分支结构

• 单if分支：条件成立之后执行子代码

  • 条件可以是布尔值，也可以是表达式
  • 判断条件可以是一个，也可以是由逻辑运算符连接的多个

• if...else分支

  • 条件：条件成立之后执行的子代码
  • else条件：条件不成立执行的子代码
  • 判断条件可以是一个，也可以是由逻辑运算符连接的多个

• if...elif...else分支

  • if 条件1：条件1成立执行的子代码
  • elif 条件2：条件1不成立，条件2成立执行的子代码
  • elif 条件3：条件1和2都不成立，条件3成立执行的子代码
  • else：上述所有的条件都不成立执行的子代码
  • if elif else三者连用，永远只会走一个分支
  • elif 和 else都不能单独使用，必须结合if

循环结构

1.while循环

• while循环（条件循环）

  • while条件：条件成立之后循环执行的子代码
  1. 先判断while后面的条件是否成立，如果成立就执行子代码
  2. 子代码运行完毕后，再次回到while后面的条件判断处，判断条件是否成立
  3. 如果成立继续运行子代码，完毕后再次判断while后面的条件是否成立
  4. 依次往复知道条件不成立才会结束

• while...break语句

  • break：表示终止本层循环，其他层的循环不受干扰

• 结束循环体的方式
  1.自己写结束条件 利用while后面的条件判断
  2.在循环体代码中添加关键字强制结束

while True:
	name = input('name>>>:')
	pwd = input('pwd>>>:')
	if name == 'jason' and pwd == '123':
		print('登录成功')
		# 强制结束
		break  # 直接结束break所在的循环体 (结束本层循环)
	else:
		print('用户名或密码错误')

• while...continue语句
  • continue：表示跳过本次循环，接下来继续执行本层循环
  • 循环打印1到10(按规矩办事) 但是到了7就跳过

count = 1
while count < 11:
	if count == 7:
		# 让count自增1
		count += 1
		# 跳过本次循环 直接开始下一次循环
		continue
	print(count)
	count += 1

• 结束本次循环 直接开始下一次循环(只影响所在的那一层循环)

while True:
	print(123)
	while True:
		print(321)
		continue
	continue

• while...else语句
  • 如果while循环没有被break掉，则执行else内部代码

count = 1
while count < 11:
	print(count)
	if count == 7:
		break
	count += 1
else:
	print('循环体按照提前定义好的条件正常结束 则会执行')

2.死循环与全局标志位

• 死循环

count = 10
while True:
	count *= 10  # 计算死循环 不允许出现 有问题

while True:
	name = input('name>>>:')  # 有等待时间 允许出现 没有问题

• 全局标志位(可以不用)

3.for循环

• for循环（for 变量名 in）：用于迭代序列（即列表，元组，字典，集合或字符串）。

  • 针对变量名的命名 如果带取值的数据有明确的指向 最好见名知意
  • 如果没有明确的指向 可以使用常见的字母
  • 通过使用for循环，我们可以为列表、元组、集合中的每个项目等执行一组语句。
  • for循环字典默认只能取到字典的key
  • for循环字符串默认每次取单个字符
  • for循环元组数据与列表一致，默认都是单数据值
  • for循环通常比while循环更容易编码并且运行效率更高，当需要遍历一个序列时，首先要考虑for循环。
  • 当对象有特定的长度时，可以使用 for 循环，没有时使用while循环。

• range方法：可以看成是一个能够帮助我们快速产生一个包含多个数据值的列表

  • 如果括号内只有一个数字，那么就是从0开始到数字减一结束(顾头不顾尾 左包含右不包含)
  • 括号内有两个数字，第一个是起始位置(包含)，第二个是终止位置(不含)
  • 括号内有三个数字，最后一个是数据的间隔数(等差数列)

• for...break语句

  • 通过使用 break 语句，我们可以在循环遍历所有项目之前停止循环
  • break也能够结束所在的那一层for循环

# 1-10  7结束
for i in range(1,11):
    if i == 7:
        break
    print(i)

• for...continue语句
  • 通过使用 continue 语句，我们可以停止循环的当前迭代，并继续下一个
  • continue也能够结束所在的那一次for循环 直接开始下一次

# 1-10  7跳过
for i in range(1, 11):
    if i == 7:
        continue
    print(i)

• for...else语句
  • for 循环中的 else 关键字指定循环结束时要执行的代码块
  • else配合for一起使用 当for循环没有被强制结束的情况下 循环体结束之后运行else子代码

for i in range(10):
    print(i)
    if i == 5:
        break
else:
    print('。。。')

数据类型的内置方法

• 内置方法：每个数据类型自带的功能(每个人的不同特长)
• 使用数据类型的内置方法统一采用句点符：数据类型.方法名()

1.整型相关方法

• 整型int()：整型就是整数，主要用于计算，没有内置方法

• 类型转换：int(待转换的数据)

  • 字符串内部是纯数字情况，可以转换
  • 字符串里面必须是纯数字才可以转换，小数点也不行

• 进制转换：二进制、八进制、十进制、十六进制

• 十进制转换其他进制:

  • bin():将十进制转二进制 0b1100100 0b是二进制数的标识
  • oct():将十进制转八进制 0o144 0o是八进制数的标识
  • hex():将十进制转十六进制 0x64 0x是十六进制数的标识

• 其他进制转十进制

  • 自动识别进制数
  • 人为指定进制数

2.浮点型相关方法

• 浮点型（float）：浮点型由整数部分与小数部分组成
• 类型转换

print(float('123'))  # 123.0
print(type(float('123')))  # float
print(float('123a123'))
print(float('123.12'))  # 可以识别一个小数点
print(float('123.123.1.2.2.2.2.2.2'))  # 不可以

• 针对布尔值的特殊情况

print(float(True))  # 1.0
print(float(False))  # 0.0
print(int(True))  # 1
print(int(False))  # 0

3.字符串相关方法

• 字符串（str）：双引号或者单引号中的数据，就是字符串
• 类型转换：兼容所有数据值

print(str(123), type(str(123)))
print(str(123.11), type(str(123.11)))
print(str([1, 2, 3, 4]), type(str([1, 2, 3, 4])))
print(str({'name': 'jason'}), type(str({'name': 'jason'})))
print(str(True), type(str(True)))
print(str((1, 2, 3, 4)), type(str((1, 2, 3, 4))))
print(str({1, 2, 3, 4}), type(str({1, 2, 3, 4})))

• 索引取值：单个字符，支持负数

s1 = 'hello jason!'
print(s1[0])  # h
print(s1[-1])  # !
print(s1[-2])  # n

• 切片取值：多个字符，支持负数，切片的顺序默认从左往右

s1 = 'hello jason!'
print(s1[0:3])  # hel  从索引0的位置开始切到索引2的位置 顾头不顾尾
print(s1[-1:-4])  # 切片的顺序默认从左往右
print(s1[-1:-4:-1])  # !no 可以通过第三个参数的正负一 控制方向
print(s1[-4:-1])  # son  顾头不顾尾

• 间隔/方向

s1 = 'hello jason!'
print(s1[:])  # 所有
print(s1[::2])  # 针对整个字符串 隔一个取一个
print(s1[0:5:1])  # hello  默认1可以不写
print(s1[0:5:2])  # hlo

• 统计字符串中字符的个数

s1 = 'hello jason!'
print(len(s1))  # print(len('hello jason!'))  12  空格也算字符

• 移除字符串首尾指导的字符

s1 = 'hello jason!'
username = input('username>>>:')
if username == 'jason':  # 'jason ' == 'jason'
	print('登录成功')
else:
	print('你不是jason!')

# 字符串调用内置方法，不是改变原数据，而是产生了新的数据
name = '  jason  '
print(len(name))  # 9
print(name.strip(), len(name.strip()))  # jason 5
res = name.strip()
print(name, len(name))  #   jason   9
print(res, len(res))  # jason 5
desc1 = '$$jason$$'
print(desc1.strip('$'))  # jason
print(desc1.lstrip('$'))  # jason$$          left
print(desc1.rstrip('$'))  # $$jason          right

username = input('username>>>:')
username = username.strip()
username = input('username>>>:').strip()  # 先获取用户输入 再立刻移除首尾空格 最后绑定给变量名username
if username == 'jason':  # 'jason ' == 'jason'
	print('登录成功')
else:
	print('你不是jason!')

• 按照指定的字符切割字符串
  • 当字符串中出现了连续的特征符号 应该考虑使用切割操作

info = 'jason|123|read'
res = info.split('|')  # 切割字符串之后结果是一个列表
print(res, type(res))  # ['jason', '123', 'read'] <class 'list'>
name, pwd, hobby = info.split('|')  # name, pwd, hobby = ['jason', '123', 'read']
print(info.split('|', maxsplit=1))  # 从左往右 只切一次  ['jason', '123|read']
print(info.rsplit('|', maxsplit=1))  # 从右往左 只切一次  ['jason|123', 'read']

• 字符串大小写相关

s2 = 'HeLLo Big BAby 666 你过的还好吗'
print(s2.lower())  # hello big baby 666 你过的还好吗
print(s2.upper())  # HELLO BIG BABY 666 你过的还好吗
print(s2.islower())  # 判断字符串中所有的字母是否是全小写  False
print(s2.isupper())  # 判断字符串中所有的字母是否是全大写  False
print('aaa'.islower())  # True
print('AAA'.isupper())  # True

code = 'JaSon666'
print('这是网页给你返回的随机验证码:%s' % code)
confirm_code = input('请输入验证码>>>:')

code_upper = code.upper()  # 将网页返回的验证码转大写
confirm_code_upper = confirm_code.upper()  # 将用户填写的验证码转大写
if code_upper == confirm_code_upper:  # 统一转大写 或者小写 if confirm_code.upper() == code.upper():  # 统一转大写 或者小写 再做比对
	print('验证码正确')
else:
	print('验证码错误')

• 字符串的格式化输出

# 方式1: 等价于%s占位，没有什么优势
res1 = 'my name is {} my age is {}'
print(res1.format('jason', 18))

# 方式2: 支持索引取值，并且支持重复使用
res2 = 'my name is {0} my age is {1} {0} {1} {1} {1}'
print(res2.format('jason', 18))

# 方式3: 支持关键字取值(按k取值)，并且支持重复使用
res3 = '{name} {name} {age} my name is {name} my age is {age}'
print(res3.format(name='jason', age=18))

# 方式4：推荐使用(******)
name = 'jason'
age = 18
print(f'my name is {name} my age is {age} {name} {age}')

• 统计字符串中指定字符出现的次数

res = 'sdashdjasdwjjkashdjasdjqwhasjdjahdjwqhdjkasdhwsdaadadadaprint(res.count('j'))
print(res.count('ad'))

• 判断字符串的开头或者结尾

res = 'jason say ha ha ha heiheihei'
print(res.startswith('jason'))
print(res.endswith('heiheihei'))

• 字符串的替换

res = 'jason jason jason SB SB SB'
print(res.replace('jason', 'tony'))  # 从左往右全部替换
print(res.replace('jason', 'tony', 1))  # 从左往右替换指定个数

• 字符串的拼接
  • 字符串支持加号拼接
  • 字符串支持乘号重复
  • join方法拼接
  • 列表中的数据都必须是字符串类型

res1 = 'hello'
res2 = 'world'
print(res1 + res2)
print(res1 * 10)
print(''.join(['hello', 'world', 'hahaha']))
print('|'.join(['hello', 'world', 'hahaha']))
print('$'.join(['jason', 'say', 666]))

• 判断字符串中是否是纯数字

print('123'.isdigit())  # True
print('123a'.isdigit())  # False
print(''.isdigit())  # False

• 查找某个字符对应的索引值
  • index查找索引，如果没有则报错
  • find查找索引，如果没有则返回-1

res = 'hello world jason'
print(res.index('d',0,5))
print(res.find('d',0,5))  # -1

• 正文相关操作

res = 'my name is jason'
print(res.title())  # My Name Is Jason
print(res.capitalize())  # My name is jason

4.列表相关方法

• 列表（list）：存储多个数据，能方便获取整体或者局部
• 类型转换：能够被for循环的数据类型都可以转换成列表

print(type(list(123)))
print(type(list(123.22)))
print(type(list('123243jasdsad')), list('123243jasdsad'))
print(type(list({'name':"jason",'pwd':123})), list({'name':"jason",'pwd':123}))

• 索引取值

l1 = ['jason', 'kevin', 'oscar', 'tony']
print(l1[0])
print(l1[-1])

• 切片操作

l1 = ['jason', 'kevin', 'oscar', 'tony']
print(l1[0:3])
print(l1[:])
print(l1[-4:-1])

• 间隔/方向

l1 = ['jason', 'kevin', 'oscar', 'tony']
print(l1[::2])

• 统计列表中数据值的个数

l1 = ['jason', 'kevin', 'oscar', 'tony']
print(len(l1))  # 4

标签：jason,name,res,笔记,print,第二周,字符串,整理,循环
来源： https://www.cnblogs.com/NianBai/p/16414454.html