其他分享
首页 > 其他分享> > 周末回顾

周末回顾

作者:互联网

数据类型及内置方法

1、整型

1.关键字:int

整型就是纯整数,本质是用来存储整数并且能够获取。

变量名 = 整数(右边是数据值,左边是绑定的名字)

a = 22

2.补充

1.类型转换
变量名 = int(变量名或数据值)
只能转换纯数字且为整数的数据值。

2.进制转换
整数是默认的十进制数,十进制可转化为二进制、八进制、十六进制
bin(数据值)		# 十进制转化为二进制
oct(数据值)		# 十进制转化为八进制
hex(数据值)		# 十进制转化为十六进制
print(bin(100))     # 0b1100100			0b是二进制的标识
print(oct(100))     # 0o144				0o是八进制的标识
print(hex(100))     # 0x64				0x是十六进制的标识

将其它进制数转换成十进制有两种方式,一种是不用提醒它要转几进制,另一种是需要提醒转换成几进制,但是第一种比较简单快捷
print(int(0b1100100))     # 100
print(int(0o144))         # 100
print(int(0x64))          # 100

print(int('0b1100100', 2))     # 100
print(int('0o144', 8))         # 100
print(int('0x64', 16))         # 100

2、浮点型

1.关键字:float

浮点型是带有一个小数点的数字,本质是存储数据。

变量名 = 小数(右边是数据值,左边是绑定的名字)

a = 2022.06

2.补充

1.类型转换
变量名 = float(变量名或数据值)
输入的字符型为整数和带有一个小数点的数据值可转化为浮点型,若将整数转化为浮点型即数据值后面加上.0

2.针对布尔值
将布尔值转换为浮点型时,对应的数值后面加.0
1.类型转换
可转换为为浮点型,后面加了.0;只能转换含有一个小数点的数值。
    print(float('222'))               # 222.0
    print(float('-222'))              # -222.0
    print(float('22.2'))              # 22.2
    print(float('222w'))              # 报错
    print(float('222.222.222'))       # 报错
    
2.针对布尔值
可将布尔值转换为对应的数值后面加.0
    print(float(True))      # 1.0
    print(float(False))     # 0.0
    
3.补充说明
python对数字的敏感度不高,有些数值进行计算时会出错。
	print(23.0 * 3.2)       # 73.60000000000001

3、字符型

1.关键字:str

字符型就是用引号引起来的部分,本质是用来存储文本

变量名 = '数据'(右边是引号引起来的部分,左边是绑定的名字)

a = '橘子'
b = "苹果"
c = '''西瓜'''
d = """甘蔗"""

2.补充

1.类型转换
任何数据类型都可以转换为字符型,如整型、浮点型、列表、字典等。

2.引号
引号有:' '," ",''' ''',""" """。由于定义字符串时内部可能同样需要使用引号,而字符串会在第一个引号后找到相同的引号会自动闭合,若单一引号则会报错。

3.内置方法

1.索引取值
变量名[ ]
s1 = 'hello word'
print(s1[3])            # l
print(s1[-3])           # o

字符串的索引取值是按从左向右的顺序,且第一个字符的索引值为0。[ ]中只有一个数值,取出的是单个字符,且空格也算一个字符,若[ ]中的数值为负数代表反向索引,顺序是从右向左。

2.切片取值
变量名[ 左 : 右 ]
s1 = 'hello word'
print(s1[2:6])          # llo
print(s1[-2:-6])        # 无
print(s1[-6:-2])        # o wo

左右都为数字中间用 : 隔开。左边的数值代表第一个索引对应的数据值,右边的数值代表最后一个索引对应的数据值,这样取到的是一段数据值,顺序是从左向右。若两个数据值都为负数,则代表反向索引,但是顺序还是从左往右,且负数小的在左负数大的在左。

变量名[ 左 : 中 : 右 ]
s1 = 'hello word'
print(s1[1:10:2])       # el od
'''[::],若想反向取值必须要三个数值都为负数,且从右往左取值'''
s1 = 'hello word'
print(s1[1:3:-1])       # 无
print(s1[-1:-3:1])      # 无
print(s1[-1:-3:-1])     # dr

左右中都为数字中间都用 : 隔开。左边的数值代表第一个索引对应的数据值,中间的数值代表最后一个索引对应的数据值,右边的数值代表间隔(差)几个字符。顺序是从左往右

3.间隔方向
变量名[ 左 : 右 ]

当左右数值都为负数时代表反向索引,但是顺序还是从左往右。[:]代表取字符串内所有的值。

s1 = 'hello word'
print(s1[:])            # hello word
print(s1[::3])          # hlwd
print(s1[-2:-6])        # 无
print(s1[-6:-2])        # o wo
变量名[ 左 : 中 : 右 ]

当所有数值都为负数时代表是反向索引,顺序为从右往左,且负数大的在左负数小的在右。

s1 = 'hello word'
print(s1[1:8:1])        # ello wo
print(s1[1:8:2])        # el o
print(s1[1:8:-1])       # 无
print(s1[-1:-8:-1])     # drow ol
print(s1[-8:-1:-1])     # 无
4.统计字符串的个数
len(要统计的变量名或字符串)

字符串(引号)内的空格、标点符号、特殊符号等都算一个字符

s1 = 'In the future, you will thank you for your efforts'
print(len(s1))  # 50
5.移除字符串首尾字符的个数
字符串或变量名.strip(要移除的字符)			# 移除首尾的字符
字符串或变量名.lstrip(要移除的字符)			# 移除左边的字符
字符串或变量名.rstrip(要移除的字符)			# 移除右边的字符
'''注意的是只能移除首尾,中间不可移除'''
s1 = '   hello word   '
print(s1, len(s1))                  #    hello word    16
print(s1.strip(), len(s1.strip()))  # hello word 10
s2 = '$$$hahahha$wowowo$$$'
print(s2.lstrip('$'))                 # hahahha$wowowo$$$
print(s2.rstrip('$'))                 # $$$hahahha$wowowo
'''字符串调用内置方法,不是改变原数据值,而是产生了新的数据值'''
s2 = '$$$hahahha$wowowo$$$'
s2.strip('$')
print(s2)                             # $$$hahahha$wowowo$$$
print(s2.strip('$'))                  # hahahha$wowowo
6.按照指定的字符切割字符串

按照指定的字符将字符串切割成几个字符串,以列表的方式输出。

字符串或变量名.split(要切割的字符)					# 要切割所有的字符
字符串或变量名.split(要切割的字符, maxsplit=整数)	   # 要切割从左到右的第几个的字符
字符串或变量名.rsplit(要切割的字符, maxsplit=整数)	   # 要切割从右到左的第几个的字符
s1 = '今天下雨了*我不喜欢下雨*但是我又讨厌热'
print(s1.split('*'))            	# ['今天下雨了', '我不喜欢下雨', '但是我又讨厌热']
print(type(s1.split('*')))      	# <class 'list'>
info1, info2, info3 = s1.split('*')	# info1, info2, info3 = ['今天下雨了', '我不喜欢下雨', '但是我又讨厌热']
print(info1, info2, info3)      	# 今天下雨了 我不喜欢下雨 但是我又讨厌热
print(s1.split('*', maxsplit=1))    # ['今天下雨了', '我不喜欢下雨*但是我又讨厌热']
print(s1.rsplit('*', maxsplit=1))   # ['今天下雨了*我不喜欢下雨', '但是我又讨厌热']
7.字符串的大小写

用于将字符串的英文设置为全部大写或者全部小写,可判断字符串中的英文是否是大小写,但是只是针对字母。

字符串或变量名.lower()			# 将字母都转换成小写
字符串或变量名.upper()			# 将字母都转换成大写
字符串或变量名.islowwer()		# 判断字母是否小写
字符串或变量名.isupper()		# 判断字母是否大写
s1 = 'HELLO WORD 8888'
s2 = 'hello word 8888'
s3 = 'Hello word 8888'
print(s1.lower())   # hello word 8888
print(s2.upper())   # HELLO WORD 8888
print(s3.lower())   # hello word 8888
print(s3.upper())   # HELLO WORD 8888
print(s1.isupper())     # True
print(s1.islower())     # False
print(s2.isupper())     # False
print(s2.islower())     # True
print(s3.islower())     # False
print(s3.isupper())     # False
8.格式化输出

格式化输出就是先占位然后再输出

方式1:%s占位,支持所有数据类型

# info1 = "亲爱的%s你好!你%s月的话费是%s,余额是%s"
# print(info1 % ('橘女士', 5, 19, 5))
# print("亲爱的%s你好!你%s月的话费是%s,余额是%s" % ('小橘', 5, 39, -15))

方式2:%d占位,只给数字站位

# info2 = "亲爱的%s你好!你%s月的话费是%s,余额是%s"
# print(info2 % ('橘女士', 5, 19, 5))
# print("亲爱的%s你好!你%s月的话费是%s,余额是%s" % ('小橘', 5, 39, -15))
# 可产生固定位数的数据
# print('%06d' % 222)

方式3:等价于%s,利用{},format()

s1 = 'my name is {}, my age is {}'
print(s1.format('orange', 22))      # my name is orange, my age is 22

方式4:支持索引取值,并可重复使用,利用{索引值},format()

s2 = '{0} {1} my name is {0}, my age is {1} {0} {1}'
print(s2.format('orange', 22))      # orange 22 my name is orange, my age is 22 orange 22

方式5:支持关键字取值,相当于按K取值,并且支持重复使用,利用{变量名},用赋值的方式给值,format()

s3 = '{name} {age} my name is {name}, my age is {age} {name} {age}'
print(s3.format(name='orange', age=22))     # orange 22 my name is orange, my age is 22 orange 22

方式6:先定义好变量然后用{变量名}占位(必记,重点!!!)。字符串的外面要加上'f',首先要定义好变量,利用{变量名},format()

name = 'orange'
age = 18
print(f'{name} {age} my name is {name}, my age is {age} {name} {age}')  # orange 22 my name is orange, my age is 22 orange 22
9.统计字符串指定字符出现的次数

统计指定字符在字符串中出现的次数,相当于利用循环查询指定字符的次数

字符串或变量名.count(指定的字符)
s1 = 'I want to See Sea'
print(s1.count('e'))  # 3
10.判断字符串的开头或者结尾

判断字符串的开头或者结尾是否是某个字符

字符串或变量名.startswith(指定的字符)     # 判断指定字符是否在开头
字符串或变量名.endswith(指定的字符)       # 判断指定字符是否在结尾
s1 = 'I want to See Sea'
print(s1.startswith('I'))   # True
print(s1.startswith('a'))   # False
print(s1.endswith('I'))     # False
print(s1.endswith('a'))     # True
11.字符串的替换

将某个字符替换成指定的字符,即旧的字符替换成新的字符。并且可以指定替换的个数,只能从左向右替换不能从右向左替换。

字符串或变量名.replace(原来的字符(老字符),指定的字符(新字符),数值)   # 将原来的字符替换成指定的字符,数值代表替换的个数。
s1 = 'I want to see sea sea sea'
print(s1.replace('sea', '大海', 2))   # I want to see 大海 大海 sea
12.字符串的拼接

将指定的字符拼接到字符串中,将要拼接的内容放入列表中,但是列表中的数据必须是字符串。拼接可使用某些符号如+、*、|、$、@...

加号也可以拼接字符串,但是注意的是只能在字符串数量较少的情况下拼接,否则会消耗内存,若字符串的数量较大推荐使用join

拼接的字符.join(要被拼接的字符)
print('girl' + 'friend')                    		# girlfriend
print('go' * 6)                            			# gogogogogogo
print(''.join(['girl', 'friend', 'you']))  			# girlfriendyou
print('@'.join(['girl', 'friend', 'you']))  		# girl@friend@you
print('$'.join(['girl', 'friend', 'you']))  		# girl$friend$you
print('$'.join(['girl', 'friend', 'you', 8888]))     # 报错
13.判断字符串中是否是纯数字

判断字符串中的数据是否都为纯数字,对应输出的布尔值是True和False

字符串或变量名.isdigit() 
print('123'.isdigit())  # True
print('123a'.isdigit())  # False
print(''.isdigit())  # False
14.查找某个字符对应的索引值

通过指定的字符找到索引的位置,指定的字符可以是单个字节也可以是多个字节,但是是按当字节的索引去查找。当出现多个时取第一个索引值。若指定索引的位置查找时注意find和index在没有找到对应的索引值出现的情况。

index(查找字符,首索引,尾索引)
find(查找字符,首索引,尾索引)
# index在进行索引查找时,从左向右找,如果没有查找到对应的索引值则会报错
# find在进行索引查找时,从左向右找,如果没有查找到对应的索引值则会返回数值-1
s1 = 'I want to See'
print(s1.index('s'))		# 10
print(s1.find('s'))			# 10
print(s1.index('s', 0, 6))	 # 报错  从索引0找到索引6
print(s1.find('s', 0, 6))	 # -1
15.正文相关操作

将字符串中的首字母大写,只针对英文单词,对中文无效。

字符串或变量名.title()
s1 = 'i want to see'
print(s1.title())   # I Want To See
s2 = '我想要回家'
print(s2.title())   # 我想要回家  

4、列表

1.关键字:list

能够存储多个数据,并且能够方便地获取整体或全部的数据。

中括号括起来,内部可以存放多个不同数据类型的数据值,数据值之间用逗号隔开。

a = [111,222,333,444,555,666]
b = ['橘子', 22, 1.57, '安徽池州']

2.补充

列表是可以进行索引取值的,索引是按照0开始从左往右数。在索引取值过程中若超出索引的范围会报错。

在类型转换过程中,能够被for循环的数据类型都可以转换成列表,记住整型和浮点型是不可以的,因为整型和浮点型是一个数而不是一个集合,不是可迭代对象。

fruit_list = ['甘蔗', '西瓜', '提子', '葡萄']
'''索引取值:通常是从0开始往后数值,与一般生活数值从1数有所不同'''
# print(fruit_list[2])  # 提子
# print(fruit_list[5])  # 报错,索引超出范围会直接报错
l1 = ['你好', '我是橘子', [111, 222, ['过来啊', '打我啊', ['hehe', 'haha', 'eeee']]]]
'''遇到较为复杂构造的数据,先明确整体有几个数据值,然后进行拆分'''
# print(l1[2])  # [111, 222, ['过来啊', '打我啊', ['hehe', 'haha', 'eeee']]]
# l2 = l1[2]
# print(l2)  # [111, 222, ['过来啊', '打我啊', ['hehe', 'haha', 'eeee']]]
# print(l2[2])  # ['过来啊', '打我啊', ['hehe', 'haha', 'eeee']]
# l3 = l2[2]
# print(l3)   # ['过来啊', '打我啊', ['hehe', 'haha', 'eeee']]
# print(l3[2])  # ['hehe', 'haha', 'eeee']
# l4 = l3[2]
# print(l4)  # ['hehe', 'haha', 'eeee']
# print(l4[2])  # eeee
# l5 = l4[2]
# print(l5)  # eeee

3.内置方法

1.索引取值
变量名[ ]

若索引中[ ]的值为正整数则代表从左往右,按照索引0到数值减一取值。若[ ]的值为负数则代表从右往左。

s1 = ['name', 'age', 22, 33]
print(s1[1])    # age
print(s1[-2])   # 22
2.切片操作
变量名[ 左 : 右]

左右都为数字中间用 : 隔开。左边的数值代表第一个索引对应的数据值,右边的数值代表最后一个索引对应的数据值,这样取到的是一段数据值,顺序是从左向右。若两个数据值都为负数,则代表反向索引,但是顺序还是从左往右,且负数小的在左负数大的在左。

s1 = ['name', 'age', 22, 33]
print(s1[1:3])      # ['age', 22]
print(s1[:])        # ['name', 'age', 22, 33]
print(s1[-1:-2])    # [] 取不到
print(s1[-2:-1])    # [22]
3.间隔/方向
变量名[ 左 : 中 : 右]

左右中都为数字中间都用 : 隔开。左边的数值代表第一个索引对应的数据值,中间的数值代表最后一个索引对应的数据值,右边的数值代表间隔(差)几个字符。顺序是从左往右。若都为负数时,表示反向取值,且负数小的在左负数大的在右,但是是从左向右取值。

s1 = ['name', 'age', 22, 33]
print(s1[0:3:2])    # ['name', 22]
print(s1[-1:-3:1])  # [] 无
print(s1[-3:-1:1])   # ['age', 22]
4.统计列表的个数
len(要统计的变量名或列表)

统计列表的个数是以列表中逗号隔开的数据值为单位进行的统计

s1 = ['name', 'age', 22, 33]
print(len(s1))      # 4

5、字典

1.关键字:dict

能够存储多个数据,能够方便获取整体或局部的数据,且对数据有解释

大括号括起来,内部存放到多个数据值,且数据的组织形式是按K:V键值对

K:对V描述性性质的信息,一般是字符串

V:是真实的数据值,可以是任意类型的数据类型

a = {'name': '橘子', 'age': 18, 'hobby': '看电影吃吃吃'}

2.补充

字典进行取值的方法时都是取K值,无法使用索引取值,因为字典是无序的

info_dict = {'name': '橘子', 'age': 18, 'hobby': '看电影吃吃吃'}
'''字典取值是使用按K取值,字典无法使用索引是因为字典是无序的'''
# print(info_dict['name'])  # 橘子
# print(info_dict['hobby'])  # 看电影吃吃吃
# print(info_dict['height'])  # 报错,K不存在

data = {
    'name': 'jason',
    'others': [
        111,
        222,
        {
            'a1': '嘿嘿',
            'a2': '哈哈',
            'a3': [
                123,
                {
                    'name': 'jason1',
                    'age': 18
                }]}]}
# 1.先获取大列表
l1 = data['others']
# print(l1)  # [111, 222, {'a1': '嘿嘿', 'a2': '哈哈', 'a3': [123, {'name': 'jason1', 'age': 18}]}]
# 2.获取大列表中的字典
d1 = l1[2]
# print(d1)  # {'a1': '嘿嘿', 'a2': '哈哈', 'a3': [123, {'name': 'jason1', 'age': 18}]}
# 3.获取字典的值
l2 = d1['a3']
# print(l2)  # [123, {'name': 'jason1', 'age': 18}]
# 4.获取列表的数据
l3 = l2[1]
# print(l3)  # {'name': 'jason1', 'age': 18}
# 5.按k取值
# print(l3['age'])
"""上述可以简写成一步"""
print(data['others'][2]['a3'][1]['age'])

6、布尔型

1.关键字:bool

用于描述事物是否正确是否可行是否合理,True和False。

布尔值是最简单的数据类型,但是使用频率高,一般定义布尔值以is开头。

is_right = True  # 真 可以 正确
is_delete = False  # 假 不可以 错误

2.补充

所有的数据类型都可以转换成布尔型,为False的数据类型有:0、None、空字符串、空列表、空字典、空集合...除了这些都是True.

所有的编程语言都有布尔值,但是关键字和值可能有所不同,如JavaScript中的关键字是Boolean。

7、元组

1.关键字:tuple

小括号括起内部能够存放任意数据类型的数据。能够存储多个数据并且能够方便获取整体或全部。

a = (1, 2, 3)
2.补充

与列表的区别是,元组内的数据值时不能直接修该的(不可修改的列表),作用是只能存储不能修改,而列表内的数据值是可以修改的。

a = [1, 2, 3]
b = (1, 2, 3)
# print(a[0])
# print(b[0])
# a[0] = 'hahaha'  # 将列表索引0重新绑定新的数据值
# print(a)  # ['hahaha', 2, 3]
# b[0] = 'hahaha'  # 将元组索引0重新绑定新的数据值,报错
# print(b)

8、集合

1.关键字:set

集合只能用去去重和关系运算,去重是自动去重复的数据,关系运算时判断两个集合之间的数据值关系。

a = {1, 2, 3}
2.补充

在定义空集合时注意的是,不能直接以变量名 = {}定义,因为这是默认字典的空集合,必须使用关键字set().

a = {}  # 大括号默认是看成字典的
b = {}
print(type(a))  # dict
print(type(b))  # dict
c = set()  # 必须使用关键字才能定义空集合
print(type(c))

用户交互

1.输入

向计算机传递数据 input()

1.先获取用户输入的数据
2.再赋值给左边的名字name
3.之后就可以通过名字name使用用户输入的数据
4.input获取到的用户输入都会转成字符串类型
name = input('请输入您的用户名:')
print(name)

2.输出

向计算机输出信息 print()

print()  # 打印数据值
print(123)  # 括号内可以直接放数据值
name = '橘子'
print(name)  # 括号内可放名字
print(123,321,323)  # 括号内也可以一次性打印多个数据值

3.补充

换行符:\n \r \r\n

最早起的换行是:\r\n

后面简化成了:\n \r(不同的操作系统可能会有变化)

基本运算符

1.算术运算

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

2.比较运算符

等于           ==
不等于         !=
大于           >     
小于           <
小于或等于      <=
大于或等于      >=

多种赋值运算

1.链式赋值

同一个值同时赋值给多个变量名

x = y = z = 10

2.交叉赋值

将m与n的数据值交换

m = 6
n = 8
m,n=n,m

3.解压赋值

将列表中的多个值取出来依次赋值给多个变量名。赋值符号左边的至少有两个及以上的名字才能够称为解压赋值。等号左边的变量名个数必须与右边包含值的个数必须相同。

若只想取开头和结尾的几个值可以用*_匹配,适合解压数据非常多的时候。

nums = [1,2,3,4]
a = nums[0]
b = nums[1]
c = nums[2]
d = nums[3]

运算符

1、逻辑运算符

and			是(条件都要成立或满足)
or			或(只需要一个条件成立或满足)
not			非(与原本意义的相反)

and链接的多个条件必须都满足时,结果才会成立,输出的布尔值为True

or链接的多个条件满足任意一个时,结果才会成立,输出的布尔值为True

not链接的多个条件只要与原本意思相反便可成立,即对就是错错就是对

三者混合使用时时具有优先级的:() > not > and > or

2、成员运算符

in			是否包含某条件,输出正确为True
not in		是否不包含某条件,输出正确为True

列表在做成员运算时,是以两个逗号之间的数据值为最小单位的,不能进行拆分和整合。

字符在做成员运算时,是以单个字节为最小单位的。

字典在做成员运算时,是以K值为最小单位的,不能使用K:V键值对也不能使用V值。

3、身份运算符

is			判断两个变量之间的内存地址是否是相同的
==			判断两个变量对应的数据值是否是相等的
id()  # 用于查看变量的内存地址

'''值相等的内存地址可能不相等,内存地址相等的值肯定相等'''

流程控制

1、顺序结构

从第一天学习python起我们所用的就是顺序结构,代码是自上而下执行的。

2、分支结构

分支结构是先判断条件是否成立满足然后再执行不同流程的代码。

if...
if...else...
if...elif...else...

1.if单分支

if 条件:
	条件成立执行的子代码块

2.if..else..

if 条件:
	条件成立执行的子代码
else:
    条件不成立执行的子代码

3.if...elif..else...

if 条件1:
	条件1成立执行的子代码
elif 条件2:
	条件1不成立条件2成立执行的子代码
else:
    条件1和条件2都不成立执行的子代码

4.if嵌套

if 条件1:
	条件1成立执行的子代码
    if 条件2:
    	条件2成立执行的子代码		# 条件2执行的条件是条件1成立

3、while循环结构

1.while循环

while 条件:
	条件成立后循环执行的子代码  
# while后面的条件成立后执行子代码,回到while处再进行条件是否成立,若成立继续执行,不成立则结束

2.while + break

while 条件:
	条件执行循环的子代码
    break	# 强制结束,退出循环,不会再回到while条件处进行判断

3.while + continue

while 条件:
	条件成立执行的子代码
    continue	# 结束本次循环回到while条件处进行判断,条件成立则进行下次循环

4.while + else

while 条件:
	条件成立执行的子代码
else:
	条件不成立执行的子代码

5.补充(死循环与全局标示位)

死循环是指在循环程序中不断计算的情况,会占用内存,不允许使用。

全局标志位,先定义全局标志位为某个值,然后后面调佣全局标志位,可改变全局标志位的值相当于条件不成立。用于循环语句中,节省代码的编写。

4、for循环结构

1.for循环

for 变量名 in 可迭代对象:  # 可以是字符串、字典、列表等,不可以是整型和浮点型
	for循环的循环体代码

2.for + break

for 变量名 in 可迭代对象:
	for循环的循环体代码
    break		# 强制结束for循环语句

3.for + continue

for 变量名 in 可迭代对象:
	for循环的循环体代码
    continue	# 结束本次循环,回到for条件判断处,若条件成立则继续执行,若不成立结束

4.for + else

for 变量名 in 可迭代对象:
	for循环的循环体代码
else:
    for循环处条件不成立执行的子代码 		# 只有当for循环条件不成立时才会执行

5.range方法

for i in range()
	条件成立执行的子代码
    
range():
    range的()里只有一个数值时,代表从0开始到数字减一(顾头不顾尾)
    
range(,)
	range的()里面有两个数值时,左边的数值代表起始的数据值,右边的数值代表最终的数据值减一
    
range(,,)
	range的()里面有三个数值时,左边的数值代表其实的数据值,中间的数值代表最终的数据值减一,右边的数据值代表差值,相当于等差数列,首项是左边的数值,中间的值代表末项的数据值减一,右边的值代表公差。

标签:字符,name,回顾,索引,s1,周末,print,变量名
来源: https://www.cnblogs.com/xiaojudeboke/p/16414240.html