python基础之数据类型

格式化输出

　　格式化（format）输出中，%s代表字符串占位符，%d代表数字占位符。（python2版本中%f代表小数占位符，%d代表整数占位符。python3版本中所有数字都用%d代表占位符。）

　　例如：输出用户的姓名、年龄、成绩

#第一种写法
name = input("请输入姓名：")
age = input("请输入年龄：")
score = input("请输入分数：")
msg = "我叫%s,今年%s,成绩%s"%(name,age,score)
print(msg)

备注：年龄和分数输入的都是数字，却用%s，而不用%d，因为input后默认输出为字符串类型，所以用%s

#第二种写法
name = input("请输入姓名：")
age = input("请输入年龄：")
score = input("请输入分数;")
msg = "我叫%(Name)s,今年%(Age)s,成绩为%(Score)s"\
    %{"Name":name,"Age":age,"Score":score}
print(msg)

备注：当代码一行放不下时，在断句处输入“\”加enter进入下一行。

msg = "我叫%s,今年%d岁,学习进度为2%%" %("某某某",21)
print(msg)

备注：字符串中表示百分比时用%%。

基本运算符

假设变量a=10,b=20

1.算数运算

2.比较运算

 

备注：!=和<>都表示不等于，平常我们用!=表示不等于。

3. 赋值运算

4.逻辑运算

　　a.逻辑运算中其优先级为()>not>and>or.

 #输出下列结果
 print(3 > 4 or 4 < 3 and 1==1)  # F
 print(1 < 2 and 3 < 4 or 1>2 )  # T
 print(2 > 1 and 3 < 4 or 4 > 5 and 2 < 1)  # T
 print(1 > 2 and 3 < 4 or 4 > 5 and 2 > 1 or 9 < 8)  # F
 print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) # F
 print(not 2 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) # F

　　b.x or y,x为真，值就是x；x为假，值就是y.

　　  x and y,x为真，值就是y；x为假，值就是x.

#输出值
print(8 or 4)    #8
print(0 and 3)    #0
print(0 or 4 and 3 or 7 or 9 and 6)     #3

 

5.in和not in

用于判断子元素是否在原字符串中：

comment = input('请输入你的评论')
sgort = '苍老师'
if sgort in comment:
    print('有非法字符,从新输入')
else:
    print('评论成功')

初识编码

　　计算机存储，网络传输，内存计算用的都是0101010101010，也就是二进制。

1.ascii码

　　计算机最初是由美国人发明的，这套编码系统主要显示英文和符号。最多用八位表示一个字符（一个字节），即2**8=256，所以ascii码最多只能表示256个符号。

2.unicode

　　随着全球一体化的发展，很显然ascii码无法将全世界的文字和符号表示出来，所以就需要一种新的可以代表所有符号的编码，于是就产生了万国码——unicode，其最初为16位表示一个字符，但不足以表示所有国家的符号，就升级为32位表示一个字符。而英文只需要八位就可以表示，许多欧洲国家语言16位就可以表示，亚洲国家24位就可以表示，所以unicode采用32位表示一个字符就造成了资源的浪费。为了解决这个问题，对unicode编码进行压缩和优化，就有了utf-8，utf-8采用最少的位数来表示一个字符。

3.GBK

　　GBK也就是国标，只能使用于某一种语言，采用16位（两个字节）表示一个字符，其只能表示常用的大部分中文，不足以表示所有中文。

4.编码中各单位的转化：

　　8bit=1byte

　　1024byte=1KB

　　1024KB=1MB

　　1024MB=1G

　　......

 5.str与bytes的相互转化

　　python中，字符串在内存中是以unicode编码存在的，保存或者网络传输的时候再转换成其他格式(比如：utf-8，gbk，gb2312，ascii...)编码。如果不转换就会出现乱码，报错。这时我们就需要编码之间的相互转化。

　　python3中的一大特性就是对文本和二进制数据作了更为清晰的区分，文本总是unicode，由str类型表示。二进制数据则由bytes类型表示。

#例如：
s = 'victory'
s1 = b'victory'
print(s.capitalize(),type(s))        #Victory <class 'str'>       字符串（string）类型
print(s1.capitalize(),type(s1))      #b'Victory' <class 'bytes'>     字节包（bytes）类型

　　str转换为bytes用     str.encode("要转换的格式")      

　　bytes转换为str用     b"XXXX".decode()

h = "apple"
h1 = h.encode("gbk")
print(h1,type(h1))   #b'apple' <class 'bytes'>
s = b"apple"
s1 = s.decode()
print(s1,type(s1))   #apple <class 'str'>

#encode() 和 decode()    括号中不加参数的时候 默认是utf-8

w = "中国"
w1 = w.encode("gbk")
print(w1,type(w1))    #b'\xd6\xd0\xb9\xfa' <class 'bytes'>
v = b'\xd6\xd0\xb9\xfa'.decode("gbk")
print(v,type(v))      #中国 <class 'str'>

 

 基础数据类型

1.数字（int）

数字主要用于计算，使用方法不多，主要记住一种：

#bit length()       当十进制用二进制表示时，最少使用的位数

i = 4
print(i.bit_length())

 

2.布尔类型（bool）

布尔类型有两种：True、False。用于反应条件的正确与否。

bool--->int    True:1    False:0

int--->bool    非0为True，0为False

同样的bool--->str     True:"True"      False："False"

　　　str--->bool      非空为True     ''空为False

3.字符串（str）

（1）字符串的索引

索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。

s = "adFn R24kl8* -fed"
s1 = s [0]
print(s1)
s2 = s [2]
print(s2)
s3 = s [4]
print(s3,type(s3))
s4 = s [7]
print(s4,type(s4))
s5 = s [-1]
print(s5)
s6 = s [-4]
print(s6)

（2）字符串的切片

切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则是顾首不顾尾）

s="i have a dream"
s1 = s[0:4]
print(s1)
s2 = s[2:5]
print(s2)
#截取到最后
s3 = s[3:]
print(s3)
s4 = s[:]
print(s4)
#加步长表示截取其中某些元素
s5 = s[::2]
print(s5)
s6 = s[2:7:3]
print(s6)
#倒着从后往前取,倒着取一段必须加步长-1
s7 = s[-1:-6:-1]
print(s7)
s8 = s[::-1]
print(s8)
s9 = s[6:1:-1]
print(s9)
#倒着取某些元素
s10= s[-2:-7:-2]
print(s10)

（3）字符串的常用方法

s = "i have 10 Yuan，It's my all"
#capitalize()首字母大写，其他字母小写
print(s.capitalize())
#swapcase()大小写字母反转
print(s.swapcase())
#title()非字母隔开的部分,首字母大写,其他小写
print(s.title())
# upper  全部大写
# lower  全部小写      这两个常见
print(s.upper())
print(s.lower())
#例如  登录时遇到的验证码 ，不区分大小写，编写程序
code = "WFfs"
your_code = input("请输入验证码：")
if your_code.upper() == code.upper():
    print("输入正确")
else:print("请重新输入")
# center()以什么居中,填充物默认空
print(s.center(40))
print(s.center(40,'*'))
# find()通过元素找索引,可以整体找,可以切片,找不到返回-1          *********这个常用
# index()通过元素找索引,可以整体找,可以切片,找不到会报错         *********
print(s.find('a'),type(s.find('a')))
print(s.find('my'),type(s.find('my')))
print(s.find('a'))
print(s.find('a',2,16))      #切片
print(s.find('O'))         #找不到输出  -1
print(s.index('O'))       #找不到报错
#startswith    判断是否以....开头             ****
# endswith     判断是否以....结尾             ****常用
print(s.startswith('i'))
print(s.startswith('a'))
print(s.startswith('v',4))
print(s.startswith('v',5))
#strip 去除字符串前后两端的空格,换行符,tab键等        *******
# m = "      从前有座山，山上有个庙,"" \
# 庙里有个和尚     风风火火         "
print(m.strip())
print(m.lstrip())
print(m.rstrip())
#例如登录上有时不小心多输入了一个空格或者tab键，如何通过程序规避
name = input("请输入姓名：").strip()
if name == "某某":
    print("输入成功")
else:print("重新输入")
#split (此处输入分割方式，分割方式必须为字符串中存在的元素,分割后的列表中不包含该元素)  以什么分割，最终形成一个列表
# str --->list  的方法             **********这个重要
print(s.split(' '))
print(s.split('a'))
print(s.split('a',1))     #  从哪儿切片
print(s.split('a',2))    # 数字表示从第几个该元素之前的这一段里面切片，该元素后面的不切为一个整体
#replace ()   用于替换   括号中依次填写"要替换内容" ，"被替换内容" ，
# # 次数（该选择要替换几处，不填表示该字符串中要替换内容出现的总次数）       ******
s1 = '走过路过的，点关注不迷路，点关注点关注点关注'
s2 = s1.replace('点','不',2)
print(s2)
#isalnum()、isalpha()、isdigit      用于判断变量中的组成元素  输出为 True   False
name='sb666'
print(name.isalnum())      #字符串由字母或数字组成
print(name.isalpha())      #字符串只由字母组成
print(name.isdigit())      #字符串只由数字组成
# format的三种表达方式       格式化输出             ************************
#第一种     必须按顺序一一对应，不能改变顺序
n = '我叫{},今年{},身高{}'.format('金鑫',"23",175)   #数字用字符串或者不用都不报错
print(n)
#第二种     必须按{}中表示的顺序一一对应，不能改变顺序
n = '我叫{0},今年{1},身高{2},我依然叫{1}'.format('金鑫',21,175)
print(n)
#第三种      可以改变顺序
n = '我叫{name},今年{age},身高{high}'.format(name = '金鑫',high=175,age=21)
print(n)

#isspace()    用于判断一个字符串是否全部由一个或者多个空格组成
a =""
print(a.isspace())   #False
a1 = " "
print(a1.isspace())   #True
a2 = "哈哈"
print(a2.isspace())     #False

# expandtabs()默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，
# 如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。
s = "\t从前有座山\t，山上有个庙，\
          庙里有个和尚\t"
ret = s.expandtabs()     #\t前面的补全
print(ret)

#join    用于以"  "这种方式将字符串从头到尾每个元素之间进行分割或者加入其他的东西    格式为："".join(变量)
s = 'asdfghjkl'         
s1 = "*".join(s)
print(s1)

下面出现的几种表示方法不仅适合于字符串，也适合其他的数据类型。

# count      用于计算元素出现的次数
s =  'ASDFASDFSADFS'
print(s.count('A'))
s = 'kj,fdlfjllkd*dsksjkxbf kd'
print(len(s))

 

4.元组（tuple）

元组被称为只读列表，即数据可以被查询，但不能被修改。字符串的索引和切片同样适用于元组。

#元组不能更改,但是如果元组元素中的列表可以被更改
tu = (1,2,'屌丝',[1,2,3],(2,3,4),True)
tu[3].pop(1)
print(tu)
tu[3].append('做头')
print(tu)

 元组和列表的相互转化              

l1 = list(tu)           tu1 = tuple(l)

5.列表（list）

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据。列表是有序的，有索引值，可切片，方便取值。

a.增

m =["《西游记》","Are you sure",110,"啷个哩个啷",True,1,123]
#append   在列表最后面增加一个元素
m.append("演员")
print(m)
#insert    在列表中的某个位置插入一个元素   格式为   插入位置的索引，插入元素
m.insert(2,"强")
print(m)
#extend    在列表的最后面增加     要加入元素中的每一个元素     数字和bool值除外
m.extend("《圣墟》")
print(m)

b.删

m =["《西游记》","Are you sure",110,"啷个哩个啷",True,1,123]
#pop       可索引
m.pop()       #什么都不填默认删除最后一个
print(m)
ret =m.pop()        #有返回值
print(ret)
#remove        按照元素去删除，括号中必须为list中的元素
m.remove("《西游记》")
print(m)
ret = m.remove(110)
print(m)           #无返回值
m.remove(1)
print(m)      #备注：元组，列表，字典中True的默认输出为1
#clear     清空列表
m.clear()
print(m)          #输出结果为：[]，而不是什么都没有
#del      功能一    删除列表
del m
print(m)
#功能二    按照索引  切片去删除
del m[0]
print(m)
del m[1:5:2]
print(m)

 

备注：在循环一个列表时，如果删除某些或者某类元素，容易出错。

l1 = [111,222,333,444,555,666,777]
#逐个删除时，会报错，因为每删除一个，整体就会前移，索引发生改变，通过索引直接逐个删会报错
for i in range(len(l1)):
    del l1[i]
print(l1)     #直接报错 list assignment index out of range

for i in range(len(l1)-1,-1,-1):
    print(i)
    del l1[i]
print(l1)        #从后往前倒着逐个删除就可避免或者直接用l1.clear() 清空列表

#如果只是删除索引为奇数的元素
#方法一  del的通过切片删除
del l1[1::2]
print(l1)
#方法二  从后往前删，就不会因为没删一个而导致整体的索引发生改变
for i in range(len(l1)-1,-1,-1):
    if i % 2 == 1:
        del l1[i]
print(l1)
#方法三  换个角度思考，删除索引为奇数的元素，那就会留下索引为偶数的元素，我们可以创建一个新列表，将索引为偶数的元素逐个的添加到新的列表中，也可以实现删除索引为奇数元素
l2 = []
for i in range(len(l1)):
    if i % 2 == 0:
        l2.append(l1[i])
l1 = l2
print(l1)

c.改

m =["《西游记》","Are you sure",110,"啷个哩个啷",True,1,123]
#按照索引去改
m[1] ="风"
print(m)
#按照切片去改    改后加入列表中的为修改元素中的每一个元素
m[1:4]="qwertyuiop"
print(m)
m[1:5] = [123,"雨",1 ]
print(m)

 备注：按照切片修改时，是先删除切片部分，在迭代的添加新元素。

d.查 

m =["《西游记》","Are you sure",110,"啷个哩个啷",True,1,123]
#查 按切片,按索引去查
print(m[2:4])
print(m[0])

#for 循环查
for i in m:
    print(i)

e.其他操作

n = [1,3,6,8,7,4,2,9,10]
# len   长度
print(len(n))
#count   出现次数
ret = n.count(3)
print(ret)
#index    通过元素找索引
print(n.index(9))
#sort       从小到大输出
n.sort()
print(n)
# #sort(reverse)    从大到小输出
n.sort(reverse=True)
print(n)
#从后往前倒着输出
n.reverse()
print(n)

f.列表的嵌套

l1 = ['小新','egon','wusir',[99,'tiabai','ritian',1,2,3],2]

l1[1] = l1[1].capitalize()     #对列表中的某个元素首字母大写
print(l1)

l1[1] = 'Alex'      #替换某个元素
print(l1)

print(l1[0])
print(l1[3])


l = l1[3]
l1[3][1] = l1[3][1].upper()        #对列表中嵌套的列表中的某个元素字母全部大写
print(l1)


l1[3][0] = str(l1[3][0] + 1)    #对嵌套元素进行自加1
print(l1)

 备注：通过"".join(变量)与(变量).split()可以实现列表和字符串的互相转换。

6.字典（dict）

　　字典是python中唯一的映射类型，采用键值对的方式存储数据。python对key（键）进行哈希函数运算，根据计算的结果决定value（值）的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字，字符串，元组。

备注：可变与不可变数据类型

　　不可变数据类型：int    str    bool     tuple

　　可变数据类型：list     dict     set

另外：在3.5版本之前，字典是无序的。3.6版本（包括3.6）之后，是有序的。这里的有序和无序是指print打印的结果是有序还是无序排列的。字典的存储还是无序的。

a.增

dic = {"name":"金鑫","age":18,"sex":"male"}
#增    格式为dic["key"] = value
#有key就覆盖，没有key就添加。
dic["name"] ="王子"
print(dic)       #覆盖
dic["hobby"] = "开船"
print(dic)

#setdeafult        有key不变，没有key才添加
dic.setdefault("name")
print(dic)
dic.setdefault("name1")
print(dic)        #添加的key不存在时，默认value为：None
dic.setdefault("nmb",123456)
print(dic)
dic.setdefault("name","太乙金星")
print(dic)         #不覆盖

 

b.删

dic = {"name":"金鑫","age":18,"sex":"male"}
#删  pop    按照key删除，有返回值       如果没有key，没有返回值但是可设置返回值
dic.pop("name")
print(dic)
ret = dic.pop("name")
print(ret)             #有返回值
ret = dic.pop("name1")
print(ret)       #没有返回值，直接报错
ret = dic.pop("name1","呜啦啦")
print(ret)        #输出为  设置的返回值"呜啦啦"

#clear     清空字典
dic.clear()
print(dic)

#del   删除字典，删除键值对
del dic
print(dic)
del dic["name"]
print(dic)

#popitem()    随机删除某个键值对，将删除的键值对以元组的形式返回
dic.popitem()
print(dic)
ret = dic.popitem()
print(ret)       #返回值为元组

在循环一个字典时，如果删除某些键值对，可能会报错。

 

#比如，删除下列字典中含有“k”元素的键值对
dict = {"k1":"kobby","k2":"jodan","a3":"james","k4":"durant"}
for i in dict:
    if "k" in i:
        del dict[i]
print(dict)   #直接报错  dictionary changed size during iteration（字典在迭代时改变大小）
#删除某些键时，由于字典的键为可哈希的（不可变数据类型）就会导致报错。
#我们可以将符合条件要删除的键添加到一个list中，在循环逐个删除，因为list为不可哈希的
dict = {"k1":"kobby","k2":"jodan","a3":"james","k4":"durant"}
l1 = []
for i in dict.keys():
    l1.append(i)    #['k1', 'k2', 'a3', 'k4']转换为由字典的键组成的list
for p in l1:
    if "k" in p:
        del dict[p]
print(dict)       #{'a3': 'james'}

 

c.改

dic = {"name":"金鑫","age":18,"sex":"male"}
#改
#覆盖式的改，   有key就覆盖    格式为dic["key"] = value

#update      格式为：（被覆盖添加的）.update(要覆盖添加的)
d = {"name":"花花","high":175}
dic.update(d)      #将d所有的键值对覆盖添加（相同的key覆盖，没有的添加）到dic中
print(dic)
print(d)

d.update(dic)       #将dic的键值对，覆盖添加到d中，dic不变
print(d)
print(dic)

d.查

dic = {"name":"金鑫","age":18,"sex":"male"}
#查
# print(dic["name"])

#get("key")    无key时，默认值为None，可设定value
value=dic.get("name")
print(value)

value1=dic.get("name1")
print(value1)        #默认为None

value2=dic.get("name2","狐狸")
print(value2)        #输出为设定value


#for  循环查

keys = dic.keys()
print(keys,type(keys))   #输出结果：dict_keys(['name', 'age', 'sex']) <class 'dict_keys'>

k = list(keys)
print(k,type(k))   #['name', 'age', 'sex'] <class 'list'>    字典中的键key转化为list
#同样的字典中的值value    和  键值对item
# values = dic.values()               items = dic.items()
# print(values)                       print(items)
# v = list(values)                    i = list(items)
# print(v) # ['金鑫', 18, 'male']     print(i)  #[('name', '金鑫'), ('age', 18), ('sex', 'male')]   元组元素的列表


for k in dic :   #dic什么都不跟   默认输出为：键key
    print(k)   #name     age      sex

for k in dic.keys():
    print(k)
for v in dic.values():
    print(v,type(v))
# 金鑫 <class 'str'>
# 18 <class 'int'>
# male <class 'str'>
for i in dic.items():
    print(i)      #输出的键值对为元组形式
# ('name', '金鑫')
# ('age', 18)
# ('sex', 'male')

#两种方式循环输出字典中的键值对
#第一种
for k,v in dic.items():
    print(k,v)
#第二种
for k in dic :
    print(k,dic[k])
# name 金鑫
# age 18
# sex male

e.字典的嵌套

dic = {
    'name':'金鑫',
    'name_list':[1,2,3,'李杰'],
    1:{
        'python10':['小黑','萌哥'],
       '老男孩':{'name':'oldboy','age':56}
    }
}
#1,[1,2,3,'李杰']追加'wusir'
#2, ['小黑','萌哥'] 小黑 萌哥中间 插入一个花哥
#3, {'name':'oldboy','age':56} 添加一个键值对,hobby:男人

#1.
dic["name_list"].append("wusir")
print(dic)

#2.
dic[1]["python10"].insert(1,"花哥")
print(dic)

#3
dic[1]["老男孩"]["hobby"] = "男人"
print(dic)
dic[1]["老男孩"].setdefault("hobby","男人")
print(dic)

#fromkeys      Returns a new dict with keys from iterable（可迭代的） and values equal to value（值不变）
dict1 = dict.fromkeys("abc","任意值")
print(dict1)   #{'a': '任意值', 'b': '任意值', 'c': '任意值'}

dict2 = dict.fromkeys([1,2,3],[])
print(dict2)      #{1: [], 2: [], 3: []}
dict2[1].append("随意")
print(dict2)    #{1: ['随意'], 2: ['随意'], 3: ['随意']}   每一个都添加，而不是增加1这个键对应的值

 

7.集合（set）

　　集合是无序的，不重复的数据集合，它里面的元素是可哈希的（不可变类型），但是集合本身是不可哈希（所以集合做不了字典的键）的。

　　集合最重要的两点：

　　1.去重：把一个列表变成集合（集合是不重复的），就自动去重了。

　　2.关系测试：两组数据之间的交集、并集、差集等关系。

a.增

set = {"流行","古典","摇滚","嘻哈"}
#add  直接添加
set1 = set.add("民谣")
print(set)

#update  迭代的添加
set2 = set.update("爵士")
print(set)  #{'摇滚', '爵', '士', '古典', '嘻哈', '流行'}

b.删

set = {"流行","古典","摇滚","嘻哈"}
#remove    按元素删除
set1 = set.remove("摇滚")
print(set)

#pop   随机删除   有返回值
set2 = set.pop()
print(set)
print(set2)

#clear   清空集合
set3 = set.clear()
print(set)    #set()

#del  删除集合
del set
print(set)

 

c.查

#for循环查
set = {"流行","古典","摇滚","嘻哈"}
for i in set:
    print(i)

d.集合的其他操作

　　(1) 交集（&或者intersection）

 

set1 = {2,3,4,5,6}
set2 = {4,6,7,8,9}
print(set1 & set2)    #{4, 6}
print(set1.intersection(set2))    #{4, 6}

 

　　(2) 并集（|或者union）

 

set1 = {2,3,4,5,6}
set2 = {4,6,7,8,9}
print(set1 | set2)    #{2, 3, 4, 5, 6, 7, 8, 9}
print(set1.union(set2))    #{2, 3, 4, 5, 6, 7, 8, 9}

 

　　(3) 差集（-或者difference）

 

set1 = {2,3,4,5,6}
set2 = {4,6,7,8,9}
print(set1 - set2)    #{2, 3, 5}
print(set1.difference(set2))    #{2, 3, 5}
print(set2 - set1)    #{8, 9, 7}
print(set2.difference(set1))    #{8, 9, 7}

 

　　(4) 反交集（^或者symmetric_difference）

 

set1 = {2,3,4,5,6}
set2 = {4,6,7,8,9}
print(set1 ^ set2)    #{2, 3, 5, 7, 8, 9}
print(set1.symmetric_difference(set2))    #{2, 3, 5, 7, 8, 9}

 

　　(5) 子集(issubset)与超集(issuperset)

 

set1 = {2,3,5}
set2 = {2,3,4,5,6}
print(set1 < set2)  #True
print(set1.issubset(set2))   #True   两者一样，都是表示set1是set2子集

print(set2 > set1)    #True
print(set2.issuperset(set1))   #True    两者一样，都是表示set2是set1超集

 

e.frozenset不可变集合，让集合变成不可变类型。

 

s = frozenset("jaadddfg")
print(s,type(s))   #frozenset({'a', 'j', 'g', 'd', 'f'}) <class 'frozenset'>

set={2,3,4,56}
print(frozenset(set),type(frozenset(set)))   #frozenset({56, 2, 3, 4}) <class 'frozenset'>

 

for循环

用户按照顺序循环可迭代对象的内容。

#输出下列字符串中的元素
s = 'My dream is have much ...'
#第一种方法   采用while循环
count = 0
while count < len(s):
    print(s[count])
    count += 1
#第二种方法   采用for循环
for i in s:
    print(i)

 range

range当做范围列表[]，列表中的元素是数字，而且是可控的有效数字范围。一般与for配合使用。

for i in range(1,10):      #[1,2,3,4...9]
    print(i)
for i in range(11):       # 默认从0开始
    print(i)
for i in range(1,10,2):    # [1,3,5,7,9]
    print(i)
for i in range(10,0,-1):
    print(i)
for i in range(10,-2,-1):
    print(i)

#输出所有元素
l1 = [1,2,3,'abc',[2,3,'sir'],7]
for i in l1:
    if type(i) == list:
        for j in i:
            print(j)
    else:
        print(i)

 enumerate

enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate将其组成一个索引序列，利用它可以同时获得索引和值。起始位置默认是零，可更改。

li = ['演员','绅士','狐狸','像风一样','方圆几里']
for i in enumerate(li):
    print(i)     #起始默认为0，输出为元组
    
for index,name in enumerate(li,1):
    print(index,name)    #输出为字符串     起始位置可更改
    
for index, name in enumerate(li, 100):       
    print(index, name)

id、is和小数据池

1.id

id用于查询内存地址

name = '本菜'
print(id(name))    #2289588520496    2289591354376    内存地址是变化的
li = [1,2,3]
print(id(li))

 

2.is

is用于判断内存地址

3.小数据池概念

　　只有数字int和字符串str才有小数据池概念，其他数据类型没有小数据池概念。

　　对于int，多个相同数字比如：count1 = 5，count2 =5，print（count1 is count2）结果为：True。在-5~256这个区间内是存在小数据池的，这个时候两个数字在内存中的存储占用同一个地址，可以节约内存。超出这个范围则会占用不同的内存地址。

　　对于str,多个相同的全部由字母组成的字符串，则都是指向一个内存地址，否则占用不同的地址。

　　相同的数字与单个字母相乘比如：name ="s"*10,name2="s"*10,print(name is name2),结果为true，在20（包含20）以内也是指向一个内存地址，否则占用不同的地址。

深浅copy

1.对于赋值运算(比如：li = [1,2,3]    l1 = li  ),   都是共同指向同一个内存地址。

2.浅拷贝copy

import copy

l1 = ["薛之谦",3,"周杰伦",["落花",6,9,"流水"],"陈奕迅"]
l2 = copy.copy(l1)
l1.append("音乐")
print(l1,id(l1))   #['薛之谦', 3, '周杰伦', ['落花', 6, 9, '流水'], '陈奕迅', '音乐'] 1917639257800
print(l2,id(l2))   #['薛之谦', 3, '周杰伦', ['落花', 6, 9, '流水'], '陈奕迅'] 1917640477256

l3 = copy.copy(l1)
l1[3].append("音乐")
print(l1,id(l1[3])) #['薛之谦', 3, '周杰伦', ['落花', 6, 9, '流水', '音乐'], '陈奕迅'] 1796287005704
print(l3,id(l3[3])) #['薛之谦', 3, '周杰伦', ['落花', 6, 9, '流水', '音乐'], '陈奕迅'] 1796287005704

　　对于浅copy来说，第一层都是独立的内存地址，从第二层开始，都是指向同一个内存地址，一变都变。

3.深拷贝deepcopy

import copy

l1 = ["薛之谦",3,"周杰伦",["落花",6,9,"流水"],"陈奕迅"]
l2  = copy.deepcopy(l1)
l1.append("音乐")
print(l1,id(l1))   #['薛之谦', 3, '周杰伦', ['落花', 6, 9, '流水'], '陈奕迅', '音乐'] 1858859206216
print(l2,id(l2))   #['薛之谦', 3, '周杰伦', ['落花', 6, 9, '流水'], '陈奕迅'] 1858859205512

l3 = copy.deepcopy(l1)
l1[3].append("音乐")
print(l1,id(l1[3])) #['薛之谦', 3, '周杰伦', ['落花', 6, 9, '流水', '音乐'], '陈奕迅'] 1858859207240
print(l3,id(l3[3])) #['薛之谦', 3, '周杰伦', ['落花', 6, 9, '流水'], '陈奕迅'] 1858859206344

　　对于深copy来说，两个是完全独立的，改变任意一个的任何元素（无论多少层），另一个绝对不改变。