python 数据类型

一.注意事项
1.所有数据类型都继承者父类type

2.staticmethod:静态方法,支持使用类名调用
参数说明:

**kwargs:可以传a1=b1的形式,也可以传字典
*args:可以传a1=b1形式，也可以传列表

3.所有序号/顺序从0开始编号
4.所有区间一般左闭右开
5.方法的参数若有self则可忽略

6.输入对象类型,按住ctrl键并单击输入的对象类型,出现该类对象所有方法

7.None为空值

8.数据类型分类:
(1)是否可变:
关于二者的区别,参见:https://blog.csdn.net/dan15188387481/article/details/49864613

不可变数据类型:Number,String,Tuple
可变数据类型:List,Dictionary,Set(也可定义成不可变的集合)

(2)访问方式:

直接访问(只能整体访问):数字
顺序访问:字符串,列表,元组
映射访问(查询快,内存占用高):字典

(3)存储方式:
原子类型(只存储一个值):数字,字符串
容器类型(可存储多个值):列表,元组,字典

9.关于常量:python不支持常量(没有语法规则限制改变一个常量的值),只能从逻辑上限制/命名上规范

二.字符串(str):
1.概念:有序的字符的集合,用于存储和表示基本的文本信息

2.特点:

• " “/’ '/”"" “”"/’’’ ‘’'扩起(包括分号)
• 其中每个组成部分称为“字符"（分号不为字符）
• 字符串中某连续部分为其"子字符串"/“子序列”
• 若为某不连续部分,不为子字符串

3.一旦创建,在内存中不可修改,所有改变字符串的操作将导致新字符串的创建(不可通过索引/切片修改,只能取值)

4.空字符串:若字符串中只包含空格,称为"空字符串"
与什么都不包含的字符串""不同

5.字符串驻留机制:

• 仅保留一份相同且不可变字符串的方法,不同的值被存放在字符串驻留池中
• 对符合标识符规则(仅包含数字,字母,下划线)的字符串会启用字符串驻留机制

>>> a='abd_33'
>>> b='abd_33'
>>> a is b
True
>>> c='dd#'
>>> d='dd#'
>>> c is d
False

6.字符串的单引号和双引号都无法取消特殊字符的含义,如果想让引号内所有字符均取消特殊意义,在引号前面加r

name＝r'l\thf' #\t特殊含义失效

unicode字符串与r连用必需在r前面,如name＝ur’l\thf’

7.分类:

·Unicode(即Str):直接写下;使用Unicode编码(仅Python3中是)
    以字符为单位进行操作
    a='asd'
·Bytes:引号前加b,默认以ASCII编码;python3增加
    以字节为单位进行操作
    只负责以字节序列(二进制)形式存储数据,至于数据表示什么内容,由程序的解析方式决定
    适合在互联网上传输
    可使用bytes()转换
    a=b'asd'

8.使用’’’ ‘’’/""" “”"创建多行字符串

>>> a='''asad
... asdac cdqdwads
... 21qwduchjubdqlj'sa
... a'''
>>> print(a)
asad
asdac cdqdwads
21qwduchjubdqlj'sa
a

9.字符串运算:

#加法:
n1="asd"
n2="erf"
n3=n1+n2="asderf"                                    
#乘法
n1="asd"
n2=n1*3="asdasdasd"
#运算时可以使用变量名也可使用字符串

10.str对象的方法:
bytes(str,encoding=" "):对字符串进行编码(转化为Bytes对象)

str:将对象转换为字符串

a,b=123,[123,4,56,'as','7d']
c=str(a)="123"
d=str(b)"[123,4,56,'as','7d']"

capitalize:首字母大写

b=a.capitalize()

casefold:全部变为小写，可处理希腊语等多种语言
lower:全部变为小写，只能处理英语

b=a.casefold/lower()

center:设置宽度，将内容居中并填充剩余部分

• 填充默认为空白，只能为一个字符

b=a.center(width,"fillchar"=none)

ljust:设置宽度,将内容居左并填充剩余部分

b=a.ljust(width,"fillchar"=none)

rjust:设置宽度,将内容居右并填充剩余部分

b=a.rjust(width,"fillchar"=none)

zfill:设置宽度,将内容居右并用"0"填充剩余部分

b=a.zfill(width)

count:查询指定子序列(sub)在指定区间中出现的次数

b=a.count('sub',start=none,end=none)=数字

encode:以 encoding 指定的编码格式编码str

a.encode(encoding='   ',errors='strict')

decode:以encoding指定的编码格式解码字符串

• errors – 设置不同错误的处理方案。默认为’strict’为编码错误引起UnicodeError;也可为 ‘ignore’/‘replace’/ ‘xmlcharrefreplace’ /‘backslashreplace’ 及通过codecs.register_error()注册的任何值

str.decode(encoding='   ',errors='strict')

endswith/startswith:查询是否以指定的前/后缀(prefix/suffix)开始/结尾

b=a.startswith/endswith(prefix/suffix,start=none,end=none)=bool
#参数说明:
prefix/suffix:指定的字符串
start:设置字符串检测的起始位置;可选,默认从头开始
end:设置字符串检测的结束位置;可选,默认到结尾

expandtabs:将字符串中的Tab符号(\t,制表符)转化为空格

• 空格数由tabsize决定(默认为8)

b=a.expandtabs(tabsize=none)

若tabsize=x,则将"a"从左到右划分,x个中未出现’\t’则跳过；出现’\t’则*’\t’之前的该组字符及空格共占x格,然后继续划分,从空格后第一个字符开始

**find:寻找指定的子序列第一次出现的位置

• 如果没有找到指定子序列,结果为-1

b=a.find('sub',start=none,end=none)=num

index:寻找指定子序列第一次出现的位置

b=a.index('sub', start=none, end=none)

如果没有找到指定子序列，直接报错

**format:替换占位符为指定的值(格式化,传值)

a="I am {name}, age{x}."
b=a.format(name="Alex", x=19) ="I am Alex, age 19." 
b=a.format(**{"name":"Alex","x":"19"})="I am Alex, age 19."

a="I am {0}, age {1}"        
b=a.format("Alex",19)="I am Alex, age 19."

format_map:将占位符替换为指定的值(只能进行一一对应,不可用序号指代)

b=a.format_map({"name":"Alex", "a":19})
#传递的是一个字典

isalnum:判断字符串是否只由数字和字母(包括汉字)组成

b=a.isalnum()=布尔值

isalpha:判断字符串是否只由字母(包括汉字)组成

b=a.isalpha()

isdecimal:判断是否只由数字构成(只支持普通格式,如1,2,的阿拉伯数字)
isdigit:判断是否只由数字构成(支持有特殊格式,如①,的阿拉伯数字,不支持中文)
isnumeric:判断是否只由数字构成,支持中文

• isdecimal使用较多(只有普通阿拉伯数字可以运算)

b=a.isdecimal()=bool
b=a.isdigit()=bool
b=a.isnumeric()=bool

isidentifier:判断是否符合标识符规则

b=a.isidentifier()=bool

islower:判断是否均为小写

b=a.islower()=布尔值

**lower:全部转换成小写

b=a.lower()

isupper:判断是否全部为大写
**upper:全部转换成大写

isprintable:判断是否可以打印(是否包含\t等不应显示的用于标识操作的符号)

b=a.isprintable()=布尔值

isspace:判断是否只包含空格

• 空字符串为False

b=a.isspace()=布尔值

istitle:判断是否每个单词均为首字母大写(是否是标题)

• 首字母指忽略非字母字符后的第一个字符/字母
• 如果有单词不包含字母，为False

b=a.istitle()=布尔值

>>>'This Is Title Case 123'.istitle()
#True
>>>'This Is NOT Title Case'.istitle()
#False

title:将字符串中每个单词的首字母变为大写
b=a.title()

lstrip:去除第一个非x字符左边的x
b=a.lstrip(‘x’=none)
rstrip:去除最后一个非x字符右边的x
**strip:去除第一个非x字符左边与最后一个非x字符右边的x
x默认为空格与\t与\n
只要"a"指定位置处有与’x’/'x’某个子序列匹配的东西，就会去除。从右/左/两次开始依次匹配，每次均进行最大匹配，匹配成功的子序列不再使用（但与其有重叠的其他子序列仍可使用）。遇到无法匹配的部分停止，即使之后仍有可以匹配的部分也不再去除。左侧与右侧之间无优先级别

a="alex"
b1=a.rstrip('0axa')="ale"
b2=a.rstrip('0ex')=a.rstrip('0e x')="al"
b3=a.rstrip('0e')="alex"

maketrans:建立对应关系(方便下一步对字符串中字符依照对应关系进行替换)
translate:对字符串中字符依照对应关系进行替换

v="asxkasaudyfgehgplhog"                          
m=str.maketrans("asdfghj", "zxcvbnm")-----建立对应关系
 n=v.translate(m)="zxxkzxzucyvbenbplnob"

partition:从左开始找到第一个sep,将字符串分割为sep左边、sep右边和"sep"三部分

b=a.partition('sep')
a="asdfesdrg"
b=a.partition('s')="a" "s" "dfesdrg"

replace:替换字符串中指定部分（可以只替换前y个，默认为所有）

b=a.replace("x1","x2",y=none)

a="alexalexalexalex"            
b=a.replace("ex", "a", 2)="alaalaalexalex"

rpartition:从右开始找到第一个sep，将字符串分割为sep左边、sep右边和"sep"三部分
**split: 从左开始寻找sep,以sep为界将字符串分割

• sep本身被删除,如不指定sep则不分割
• 最大分割次数(maxsplit)可以指定,默认无限制(即-1)

b=a.split(sep=none,maxsplit=-1)

a="asdesjhsis"
b1=a.split()=['asdesjhsis']
b2=a.split('s')=['a','de','jh','i']        
b3=a.split('s',1)=['a','desjhsis']

split结果为列表
rsplit:从右开始寻找sep,以sep为界将字符串分割

• sep本身被删除
• split可在制作计算器时使用
• 正则表达式也可以分割,且可以指定是否包含sep

a1,a2,a3…=a.split("x")

splitlines:根据换行符\n进行分割，规则同split；keepends为True时保留sep，为False时不保留，默认不保留

b=a.splitlines(keepends=none)

swapcase:大小写转换

a="ASDserG"
b=a.swapcase()="asdSERg"

三.数字(numeric;num):不使用" "且为数字
1.运算:

+,-,*,/:加减乘除
#运算时可以使用变量名也可使用数字
%:除后取余
39%8=7
**:次方运算
2**4=16
//:除后取商
39//8=4

2.进制与类型:
(1)进制表示:
2进制表示整数时,数值前要加前缀0b/0B;8进制表示整数时,数值前要加前缀0o/0O;16进制表示整数时,数字前要加0X/0x—这三种进制可方便的进行位运算
(2)num类型:

• Python3 支持int,float,bool,complex
• Python2中没有bool,用0表示False,用1表示True
• Python3中,把True和False定义成关键字,但它们的值还是1和0,可以和数字相加

3.整型int:数学上的整数

• python3中不管数字多大,均为int
• python2中不超过某个范围(32位机器:-2³¹～2³¹-1;64位系统:-2⁶³～2⁶³-1)为int,超过某个范围则为long

4.长整型long:

• 通常做法是在数字尾部加大写字母L/小写字母l表示该num是long,如:a=9223372036854775808L
• 如果发生溢出,python2会自动将int转换为long

5.浮点数float:就是数学中的小数(按照科学记数法表示时,浮点数的小数点位置可变,如1.23109=12.3108)

• 在内存中,float用a * bⁿ形式记录
• 浮点数可以用数学写法,如1.23,3.14,-9.01
• 但是对于很大/小的浮点数,就必须用科学计数法表示;把10用e替代;1.23 * 10⁹就是1.23e(+)9,或12.3e8;0.000012可以写成1.2e-5
• 整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的,浮点数运算可能有四舍五入的误差
• int与float混合运算,结果为float
• float最大值为1.7976931348623157e+308

6.复数complex:

• 复数由实数部分和虚数部分组成,一般形式为x＋yj
• x是复数的实数部分,y是复数的虚数部分,x,y都是实数
• 注意,j大小写都可以

7.布尔值(bool):为”真“(True)/”假“(False)–某判断的结果

• 又称逻辑型(logical)

not True=False ; not False=True

• 特殊值False,None,各种类型(包括float,complex等)的数值0,空序列(如空字符串"",空元组(),空列表[ ]),空映射(如空字典{ }）都被视为假;而其他各种值都被视为真,包括特殊值True
• 这种差别类似于"有些东西"和"没有东西"的差别
• True和False不过是0和1的别名,作用是相同的
• 但各种为假的对象并不相等,如:[]!="",()!=False

>>> True 
True 
>>> False 
False 
>>> True == 1 
True 
>>> False == 0 
True 
>>> True + False + 42 
43  

8.num对象的方法：
**int:转换成整型

• a可为任何进制(由base控制),默认为10进制;b为10进制
• 如果a是float,直接截取到整数位
• complex无法使用
• 只能转换符合int格式的str(float格式的不行)

b=int(a,base=none)

int(False)=0,int(True)=1

bit_length:查看数字在二进制下表示至少需要的位数

• n必须经过指代,由变量名表示,不可直接使用数字

>>> a=5.bit_length()
  File "<stdin>", line 1
    a=5.bit_length()
                 ^
SyntaxError: invalid syntax
>>> n=5
>>> a=n.bit_length()
>>> a
3

bool:转换成布尔值

b=bool(a)=True/False

四.列表(list):
1.特点:

• 用[ ]扩起
• 元素间用“,”进行分割
• 按照索引,存放各种数据类型
• 每个位置代表一个元素
• 元素可以是num、str、list、bool等任何类型

2.list和tuple的运算:

#加法(合并):
li1+li2=li3;tu1+tu2=tu3
a=[1,2],b=[3,4]
c=a+b=[1,2,3,4]
#乘法:
a=[1,2]
b=a*3=[1,2,1,2,1,2]

3.索引与切片:

#修改:
list[x]=a #将第x个元素改为a
list[x1:x2]=[a1,a2,…] #将区间内元素依次改为a1、a2…
#删除:
del list[x] #将第x个元素删除
del list[x1:x2] #删除区间内元素
#获取:
list[x]/list[x1:x2]

4.推导式创建列表

li=[f(x) for x in range([start,]end[,step] if 条件)]

5.多维列表
一维列表可以存储一维,线性的数据;二维列表可以存储二维,表格式的数据

几维列表,列表就要嵌套几层

li=[[[...],[...]...],[...],[...]...]

如下表数据:

代码:

内存结构:
6.list的方法:
list():转化成列表
本质上是使用for循环,可以进行for循环才适用

b=list(str/tuple/dict/set)=list
#dict生成的列表中元素为dict中的键
b=list(range([start,]end[,step]))=list

**append:追加元素(p_object)到原值的最后一个
不产生新列表,b为空值

b=li.append(p_pbject)

li1=[11,22,33]
print(li1)    #结果为[11,22,33]  
li2=li1.append(44)=None
print(li1,li2)    #结果为li1=[11,22,33,44],li2=None

clear:清空

b=a.clear   #a=b=None

copy:(浅)拷贝

a2=a1.cpoy()=a1

count:计量a在列表中出现的次数

b=[x1,x2...].count(a)=int

**extend:扩展原来的列表将另一个interable(可迭代对象)中的元素追加进原本的列表来(利用for循环)

interable1.extend(iterable2)

i1=[11,22,33]
i2=["I am","you"] 
i1.extend(i2)
print(i1)   #结果为[11,22,33,"I am","you"]
i3="I am"
i1.extend(i3)
print(i1)   #结果为[11,22,33,"I am","you","I"," ","a","m"]

index:寻找指定元素第一次出现的位置

n=li.index(value,start=none,stop=none) 

**insert:在指定位置(index)插入指定元素(p_object)

li.insert(index,p_object)

pop:删除指定位置的元素,默认为最后一个
删除的值b仍可获取到

b=li.pop(index=none)

remove:删除列表中第一个(左边优先)指定的值,之后即使还有指定的值也不删除

li.remove(value)
li=[11,22,33,22,44]
v=li.pop()
print(li,v)   #结果为[11,22,33,22]   44    
li.remove(22)
print(li)   #结果为[11,33,22]

reverse:将列表中元素顺序颠倒

li.reverse()

sort():将列表中元素按指定顺序重新排列
可指定函数/λ表达式(cmp),二者均默认没有
可指定从小到大(reverse=False)/从大到小(reverse=True)

li.sort(list,key=none,cmp=none,reverse=False)
#参数:
list:要重排的list
key:可选;作用不清楚
cmp:如果指定了该参数会使用该参数的方法进行排序;可选,默认为none
reverse:排序规则,=True为降序,=False为升序(默认)

a=[1,4,2,5]
a.sort()
print(a)
#结果:[1, 2, 4, 5]

五.元组(tuple)
1.特点:

• 用( )扩起，用","进行分割
• 由列表修改为(一级)元素不可修改/增加/删除的类型(可以先转换成字符串,修改后变回元组）
• 但元素如果是可修改的数据类型,可修改元素的元素
• 大部分操作与list相同
• 访问/处理速度快于list

2.一般写元组时最后一个元素后多加一个",",与参数的( )分出 区别

li=(x1,x2,x3,x4,...,)

#否则tuple中只有1个元素时,数据类型会被识别错误
>>> a=(1)
>>> type(a)
<class 'int'>
>>> b=(1,)
>>> type(b)
<class 'tuple'>
>>> c=(1,2)
>>> type(c)
<class 'tuple'>

3.tuple的方法:
tuple:转换成元组（字符串、列表）

tu=tuple([1,2])

count:指定值出现次数;

tu.count(value)

index:返回指定值第一次出现的位置

tu.index(value,start=stop=none)

max/min:同list

六.字典(dict):
1.特点:

• 由{ }扩起，用","分割，元素为键值对(key1:value1)

dict={key1:value1,key2:value2...}

• 值可以为任何数据类型，可嵌套任意层
• 键可以为str,int,bool,tuple,set等可hash的数据类型;不可为list,dict(无法直接写成哈希表)
• 排列无序(不可使用切片,索引为定义的键)
• key重复时,只随机保留一个(注意False/True和0/1重复)

2.dict的方法:
del:根据索引删除指定的键值对

del dict[k]/del dict[k][x][k]

**keys():获取所有键

info.keys()

**values():获取所有值

info.values()

**items():获取所有键值对

info.items()

info={'Google': 'www.google.com', 'Runoob': 'www.runoob.com', 'taobao': 'www.taobao.com'}
for k,v in info.items():
    print(k,v)
#Google www.google.com
#taobao www.taobao.com
#Runoob www.runoob.com    
print("字典值:%s"%dict.items())
#[('Google','www.google.com'),('taobao','www.taobao.com'),('Runoob','www.runoob.com')]

clear:清空

info.clear() 

copy:浅拷贝(拷贝出的目标对象的指针和源对象的指针指向的内存空间是同一块空间)

info2=info1.copy()

fromkeys(staticmethod): 根据序列生成新字典并指定统一的值

• 新key等于第一个参数args中的元素
• 所有value等于第二个参数kwargs
• kwargs=none,value=none
• 参数args需为可迭代对象(元组,列表,字符串)

dict.fromkeys(args,kwargs)

>>> a={}
>>> a.fromkeys((1,2,3),3)
{1: 3, 2: 3, 3: 3}
>>> a.fromkeys((1,2,3),(3,4))
{1: (3, 4), 2: (3, 4), 3: (3, 4)}

**get:寻找指定的k(ey)，如果不存在，返回特定值d(默认为none)

info.get(k,d=none)

pop:删除指定的k(ey)及其对应的value

info.pop(k,d=none)

可得到删除的value，但无法获得删除的key
要移除的键值对不存在时，返回指定值d(默认为none)

popitem:随机删除1个键值对并获得由删除的key和value构成的元组

info.popitem()
info={"k1":'v1',"k2":'v2'} 
tu=info.popitem()
print(info,tu)   #结果为{"k1":'v1'},(k2,v2,)    
k,v=info.popitem()
print(info,k,v)   #结果为{"k1":'v1'},k2,v2 

setdefault:设置键值对

info.setdefault(k,d=none)

如果k(ey)存在，不设置并获取k对应的value；如果k不存在，设置一个新键值对k:d

**update:更新键值对(已有的覆盖,没有的加入)

info.update({k1:v1})
info.update(['x1y1'...])
info.update(('x1y1','x2y2'...))
#x1,y1分别为1个字符(1个str只能是2个字符);生成键值对x1:y1
#list/tuple中元素只能是str
#tuple中最少有2个元素

七.集合(set):
1.特点:

• 由不同元素组成的集合,集合中是一组无序排列的可hash/不可变值(num,str,tuple)
• 用{ }扩起,用","分隔
• 目的是将不同的值存放到一起,不同的集合间用来做关系运算,无需纠结于集合中单个值
• 定义时即使有相同元素,也只保留其中一个

s={e1,e2,e3...} 

2.set的方法:
set:转换成集合

s=set("hello")={"h","e","l","o"}

frozenset:转换成不可变集合

s=frozenset("hello")={"h","e","l","o"}  

add:添加元素

• 一次只能添加一个

s.add(num/str/tuple)

clear:清空

s.clear()

copy:浅拷贝(不拷贝内容,只拷贝最上层引用)

• 二者内存地址相同
• 对一方修改会影响另一方

s2=s1.copy()

deepcope():深拷贝(同时拷贝所有内容和所有引用引用;即在新的内存区域复制一个原对象,并被新变量引用)

• 二者内存地址不同
• 对一方修改不会影响另一方

s2=s1.deepcopy()

pop:随机删除一个元素

s.pop()

remove:删除指定元素

• 如果指定元素不存在,报错

s.remove(x)

discard:删除指定元素
指定元素不存在,无变化

s.discard(x)

intersection/&:求交集

• 返回一个新set

s_i=s1.intersection(s1)=s1&s2 

intersection_update:去除set中不存在与setn的元素

• 修改原本的set

set_i.intersection_update(set1, set2 ... etc)
#参数说明:
setn:要查找相同元素的集合;最少1个
set_i=set_i&set1&...

>>> x = {"apple", "banana", "cherry"}
>>> y = {"google", "runoob", "apple"}
>>> x.intersection_update(y)
>>> x
{'apple'}

union/|:求并集

s_u=s1.union(s2)=s1|s2

update:更新多个值

s1.update(x)   #x可为任何可迭代对象             
#加入的元素为x中原本s1中不存在的元素  

difference/-:求差集

• 返回一个新的set

s_d=s1.difference(s2)=s1-s2!=s2-s1

difference_update: 从原集合中移除另一个集合中的元素

s1.difference_update(s2)
s1=s1-s2

symmetric_difference/^:交叉补集并(集减交集)

• 返回一个新set

s_sd=s1.symmetric_difference(s2)=s1^s2

symmetric_difference_update:修改集合为交叉补集

symmetric_difference_update:s1=s1^s2                                      

isdisjoint:判断是否有交集

b=s1.isdisjoint(s2)=True/False

issubset:s1是否为s2的子集(s1<=s2)

b=s1.issubset(s2)=s1<=s2=True/False

issuperset:s1是否是s2的父集(s1>=s2)

b=s1.issuperset(s2)=s1>=s2=True/False

3.运算符号:

交集&
并集|
差集-
交叉补集^
A是B的真子集A<B
A是B的真父集A>B
A是B的子集A<=B
A是B的父集A>=B
A等于B A==B
A不等于B A!=B

八.多种数据类型通用功能
1.type:查看数据类型

print(type(a)):输出数据类型

2.len:返回字符串长度/列表元素个数/字典总长度(键值对总数)/元组元素个数

• 数字类型数据不能使用len()函数
• 一个汉字的长度在python3中为1,在python2中为3

print(len(a))

3.索引:[序号]:获取“索引/下标”确定的位置处的字符
切片:[序号1:序号2]:获取由“切片”确定的区间内(左闭右开)的所有字符

• 序号1为-1时,什么都不取
• 序号2为-1时,取最后一位外的所有位
• 均为-1时，什么都不取

a[x1][x2][x3]...

• 如果不存在,报错
• 切片结果的数据类型与原本数据类型相同
• 不可修改的数据类型不能使用索引和切片进行修改,只能取值
• 字典的索引为定义的键,不可用切片
• 集合无法使用

a="qaz"
b=a[0]="q"

a="asd  f"
b=a[2:5]="d  "

info={k1:v1,k2:v2,k3:v3}
info[k1]=v1   #获得的是value

#根据索引/切片删除元素
a=[1,2,3]
del a[0]

• 序号为负数时表示从后开始数;最后1个为-1,倒数第2个为-2…注意切片两个序号均为负数时开始要小于结束

a='abcdefg'
b=a[-4:-1]
b#'def'
c=a[1:-2]
c#'bcde'

4.range:创建在指定区间内的整数

• start为开始位置,默认为0
• step为步长,默认为1
• end为结束位置,默认为-1(最后一位)

a=range(start=none, end, scan=n one)

a=range(10)                     
print(a)

b=range(5,10)   #*只有两项时默认为范围*，后项需大于前项，否则输出空值
print(b)

c=range(0, 20, 5)
print(c）

输出结果在python3中为range(0,10)/range(5,10)/range(0,20,5)（此时数尚未创建，在进行for循环时一个一个创建）,在python2中为[0,1,2,3,4,5,6,7,8,9]/[5,6,7,8,9]/[0,5,10,15]（此时数立刻创建）

**join:在相邻的两个字符/元素间插入指定字符（依靠for循环）

b=a.join(iterable)
test="你是风儿我是沙"
a=" "        
b=a.join(test)=" ".join("你是风儿我是沙")="你 是 风 儿 我 是 沙"

test=['alex', 'eric', 'rain']
a=“_”
b=a.join(test)="alex_eric_rain"

可用于元素只包含字符串的列表/元组转换成字符串

str/list/tuple/dict/set/file.iter():转换成可迭代对象

8.代码块：" : "加回车后为一个代码块