Python修炼之路-数据类型

Python编程之列表

列表是一个使用一对中括号"[   ]" 括起来的有序的集合，可以通过索引访问列表元素，也可以增加和删除元素。

列表的索引：第一个元素索引为0，最后一个元素索引为-1。

#列表的定义与访问
>>> L = ['python', 11, True]
>>> print(L)     #['python', 11, True]
>>> L[-1]        # True
>>> L[0]         # 'python'
>>> L[2]         # True

列表常用方法

实例

#***************插入*******************
>>> L = ['python', 11, True]
>>> L.append('hello')                            #append插入
>>> L
#       ['python', 11, True, 'hello']
>>> L.insert(0,False)                      #指定位置插入
>>> L
#[False, 'python', 11, True, 'hello']
>>> L.insert(10,'world')                  #插入索引区别
>>> L
#[False, 'python', 11, True, 'hello', 'world']
>>> L[5]
#'world'

#***************删除*******************
>>> L = ['python', 11, True]
>>> L.pop()     #True                      #pop弹出，默认弹出最后一个
>>> L              #['python', 11]
>>> L.pop(0)   #'python'                 #pop指定位置弹出
>>> L            #[11]
>>> L = ['python', 11, True]
>>> L.remove(11)                           #remove删除
>>> L               #['python', True]
>>> L = ["A","B","C","D","E"]
>>> del L[2]                                  #删除一个元素
>>> L               #['A', 'B', 'D', 'E']
>>> del L[2:]                                #删除一个范围内的元素
>>> L              #['A', 'B']
#***************更新*******************
>>> L = ['python', 11, True]
>>> L[2] = False
>>> L                 #['python', 11, False]

#***************排序与索引*****************
>>> L.sort(reverse=True)     #排序
>>> L     #['E', 'D', 'C', 'B', 'A']
>>> L = ["A",1,"Bob"]       #注意不能和数字在一起排序
>>> L.sort()
Traceback (most recent call last):
  File "<pyshell#34>", line 1, in <module>
    L.sort()
TypeError: unorderable types: int() < str()
>>> L = ["A","","Bob"]       #转换成字符串即可
>>> L.sort()
>>> L                    #['1', 'A', 'Bob']
>>> L.reverse()    #参考上面reverse=False
>>> L    #['Bob', 'A', '1']

#***************扩展**********************
>>> M = ["",2,"C"]
>>> L.extend(M)
>>> L                #['Bob', 'A', '1', '1', 2, 'C']

#***************其他用法*******************
>>> L = ["A","B","C","D","E"]
>>> L.index("B")                #1    返回索引值
>>> L.count('C')                 #1    统计"value"出现的次数

列表切片

列表切片：用于从列表或元组中截取元素。

截取原则：自左向右截取，顾头不顾尾原则。

usage: if the first index is ‘0’ or the last one, which could be ignored; Meanwhile slice could appoint the third parameter that means intercept one element out of every N element.

L[1:3]: it means that the index is from one to  three, but it doesn’t include this element which index is three.

>>> L = ['A',1,True,'a']
>>> L[1:3]              #[1, True]
>>> L = ['A',1,True,’a’]
>>> L[:2]               #['A', 1]
>>> L[:]                 #['A', 1, True, 'a']
>>> L = range(1,10)
>>> L[2::3]            #[3, 6, 9]
>>> L[2:7:3]          #[3, 6]
>>> L = range(1,11)
>>> L
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> L[-5:-1]
[6, 7, 8, 9]
>>> L[-5:]
[6, 7, 8, 9, 10]
>>> L[-5::3]
[6, 9]

字符串切片处理

>>> 'asdfghjkl'[:3]
'asd'
>>> 'asdfghjkl'[-3:]
'jkl'
>>> 'asdfghjkl'[::2]
'adgjl'

遍历列表

#**********enumerate用法：返回列表的索引以及元素值********************
f = open("file","r",encoding="utf-8")    #文件句柄，输出中文时注意文件编码
count = 0
for index, line in enumerate(f):
    count += 1
print(count)          #9    一共有多少行
print(index)          #8    最后一个索引值
f.close()

---

Python编程之元组

元组(tuple)：一个用括号"（）"括起来的有序序列，但是一旦创建便不可修改，所以又叫只读序列。

元组只有两个方法：count与index，参考list。

# if there is one element in tuple, there should be add one ‘,’ after element.
>>> t = ('python',11,True)
>>> t[0]
'python'
>>> t = (1)        #这只是一个数字，不是元组
>>> t
1
>>> t = (1,)
>>> t
(1,)

一个特殊的元组

>>> t = ('a','b',['A','B'])
>>> t
('a', 'b', ['A', 'B'])
>>> L = t[2]
>>> L[0] = 'X'
>>> L[1] = 'Y‘
>>> t
('a', 'b', ['X', 'Y'])

The unchangeable means tuple appointed should not be changed. Example, if appointed to a, it shouldn’t change to b.

#关于更多的赋值与指向，可以参考深浅拷贝。

---

Python编程之字符串操作

字符串定义：用单引号或双引号括起来任意字符。

特性：不可修改

转义字符：\

#　　　\n : Enter       \t:  tab    \\: \   \': '

raw string: 可以不使用"\"来转义， 禁止转义。

print(r'\(~_~)/(~_~)/')
#\(~_~)/(~_~)/

使用:"""..."""或者'''...'''表示多行字符串。

print('''"To be, or not to be\": that is the question.
Whether it\'s nobler in the mind to suffer.''')    

字符串常用方法

S.lower()	小写
S.upper()	大写
S.swapcase()	大小写互换
S.capitalize()	首字母大写
S.title()	只有首字母大写，其余为小写
S.ljust(width,"fillchar")	输出width个字符，S左对齐，不足部分用fillchar填充，默认的为空格
S.rjust(width,"fillchar")	右对齐
S.center(width, "fillchar")
S.zfill(width)	把S变成width长，并在右对齐，不足部分用0补足，左边补0
S.find(substr, [start, [end]])	返回S中出现substr的第一个字母的标号，如果S中没有substr则返回-1。start和end作用就相当于在S[start:end]中搜索
S.index(substr, [start, [end]])	与find()相同，只是在S中没有substr时，会返回一个运行时错误
S.rfind(substr, [start, [end]])	返回S中最后出现的substr的第一个字母的标号，如果S中没有substr则返回-1，也就是说从右边算起的第一次出现的substr的首字母标号
S.rindex(substr, [start, [end]])	计算substr在S中出现的次数
S.replace(oldstr, newstr, [count])	把S中的oldstar替换为newstr，count为替换次数。这是替换的通用形式，还有一些函数进行特殊字符的替换
S.strip([chars])	把S中前后chars中有的字符全部去掉，可以理解为把S前后chars替换为None
S.rstrip([chars])
S.lstrip([chars])
S.expandtabs([tabsize])	把S中的tab字符替换没空格，每个tab替换为tabsize个空格，默认是8个
S.split([sep, [maxsplit]])	以sep为分隔符，把S分成一个list。maxsplit表示分割的次数。默认的分割符为空白字符
S.rsplit([sep, [maxsplit]])
S.splitlines([keepends])	把S按照行分割符分为一个list，keepends是一个bool值，如果为真每行后而会保留行分割符。
S.join(seq)	把seq代表的序列（字符串序列），用S连接起来
S.encode([encoding,[errors]])	编码
S.decode([encoding,[errors]])	译码
S.startwith(prefix[,start[,end]])	是否以prefix开头
S.endwith(suffix[,start[,end]])	以suffix结尾
S.isalnum()	是否全是字母和数字，并至少有一个字符
S.isalpha()	是否全是字母，并至少有一个字符
S.isdigit()	是否全是数字，并至少有一个字符，如果是全数字返回True,否则返回False.
S.isspace()	是否全是空白字符，并至少有一个字符
S.islower()	S中的字母是否全是小写
S.isupper()	S中的字母是否便是大写
S.istitle()	S是否是首字母大写的
trantab = str.maketrans(intab, outtab)	制表
S.translate(trantab)	翻译，和上面的结合使用

实例

poem = "gently I go as quietly as I came here"
print(poem.capitalize())                  #首字母大写
# Gently i go as quietly as i came here

print(poem.lower())                        #所有字母变成小写
#  gently i go as quietly as i came here

print(poem.upper())
#GENTLY I GO AS QUIETLY AS I CAME HERE

print(poem.swapcase())
# GENTLY i GO AS QUIETLY AS i CAME HERE

print(poem.casefold())                      #大写全部变小写
#gently i go as quietly as i came here

print(poem.center(80,"-"))      #输出80个字符，不足80个以“-”在字符串前后补充，字符串居中
#---------------------gently I go as quietly as I came here----------------------

print(poem.ljust(80,"*"))           #打印80个字符，字符串在前，不足80的部分用"*"补充
#  gently I go as quietly as I came here*******************************************

print(poem.rjust(80,"-"))
#-------------------------------------------gently I go as quietly as I came here

print(poem.zfill(80))                   #把字符串变成80个字符宽度，不足80的用0补足
#0000000000000000000000000000000000000000000gently I go as quietly as I came here

print(poem.count("e"))     #统计 e 出现次数
#

print(poem.find("e"))              #返回字符串中第一次出现“e”的标号，如果没有则返回-1；
# 1                                  也可以poem.find("e",[start, [end]])设置返回，相当于

poem[start:end]
print(poem.rfind("e"))         #返回poem中最后一次出现"e"的标号，如果没有则返回-1，
#

print(poem.rindex("e"))            #同rfind()
#
print(poem.replace("e","E",2))     #replace(oldstr, newstr, [count]) ， 替换
#gEntly I go as quiEtly as I came here

print("\n\tPython\t  is\n".strip())        #把前后的空格，换行制表等字符去掉
print("\n\tPython\t  is\n".lstrip())
print("\n\tPython\t  is\n".rstrip())
print("\n\tPython\t  is".rstrip("s"))        #也可以指定字符去掉
'''
Python      is
Python      is

    Python      is

    Python      i
'''

print(poem.encode())      #将字符串编码成bytes格式，解码为poem1.decode()
# b'gently I go as quietly as I came here'

print(poem.endswith("re"))  #判断字符串是否以 re结尾
# True

print("Python is a programming \tlanguage".expandtabs(10))   #将\t转换成10个空格，默认是8个
# Python is a programming       language

print(poem.find('e'))    #查找e，返回第一次找到'e'的索引；如果找不到，返回-1
#

#------------------------format格式化输出--------------------------
msg = "{} is a programming language, using {}"
print(msg.format("Python",3))
# Python is a programming language, using 3

msg = "{1} is a programming language, using {0}"
print(msg.format("Python",3))
# 3 is a programming language, using Python

msg = "{name} is a programming language, using {version}"
print(msg.format(version=3,name="Python"))
#Python is a programming language, using 3

print(msg.format_map({ 'name':'Python','version':3}))
#Python is a programming language, using 3

print(poem.index('h'))    #返回字符串中第一个字符'h'的索引，如果没有会出现错误
#

print('90Ads'.isalnum())     #字符串是否只包含字母或者数字，其他字符会返回False
#True                  

print(''.isdigit())      #字符串是否是只包含数字，如果包括其他字符，小数点，字母则返回False
#True                   

print(''.isnumeric())     #字符串是否只包含数字或者字符串数字
# True

print(poem.isprintable())     #是否可打印

print(' '.isspace())          #是否为空格，含有其他字符返回False

print(poem.istitle())         #是否为title，即每个单词的首字母是否为大写

print('AA133.'.isupper())        #字符串中字母是否全部为大写，可以包括数字，其他字符等，不能包括小写字母
#True

print(poem.split())        #把poem分割成一个list，也可以指定分割符合分割次数，如下，默认分割符为空白符
#['gently', 'I', 'go', 'as', 'quietly', 'as', 'I', 'came', 'here']

print(poem.rsplit(" ",2))    #自右向左分割
# ['gently I go as quietly as I', 'came', 'here']

print("""111111111111
222222222222
3333333333""".splitlines(True))         #按照行分割符分割成一个list，如果为真，每行后会保留分割符

#['111111111111\n', '222222222222\n', '3333333333']
print("-".join(["python","is","a"])) #把["python","is","a"]序列，一个字符一个字符的用“-”串起来
#python-is-a

intab = "aeiou"  #This is the string having actual characters.
outtab = "" #This is the string having corresponding mapping character
trantab = str.maketrans(intab, outtab)
print(poem.translate(trantab))
#g2ntly I g4 1s q532tly 1s I c1m2 h2r2

print("as d".isidentifier()) #检测一段字符串可否被当作标志符，即是否符合变量命名规则
#False

print(poem.partition("e"))    #如果字符串包含指定的分隔符，则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。
#('g', 'e', 'ntly I go as quietly as I came here')

---

Python编程之字典

访问元素更快，但是需要更多内存，通过key来访问value，所以key是唯一的；

key-value是无序的，区别list；

key是不可变的，数字，字符串，元组都可以作为key，list除外。

可以通过if判断key是否在字典中： if key in dict:

字典的查找、修改、增加、删除等用法。

info = {
    "stu1" : "Jack",
    "stu2" : "Bob",
    "stu3" : "Adam"
}
print(info)
# {'stu1': 'Jack', 'stu2': 'Bob', 'stu3': 'Adam'}     #无序的，每次打印顺序会变动

#****************查找 ****************************
print(info["stu1"])         #不建议使用这种方式查找，如果所查元素不存在，会出错，Key error
print(info.get("stu1"))     #查找，如果不存在返回None，安全获取
print("stu2" in info)       #如果存在则返回True，判断是否存在；相当于python2.x中的info.has_key('stu2')
#True

#****************修改 *************************
info["stu3"] = "Mary"    #如果存在，则是修改
print(info)
#{'stu2': 'Bob', 'stu1': 'Jack', 'stu3': 'Mary'}

#***************创建 *************************
info["stu4"] = "Kerry"    #如果不存在，则是创建
print(info)
#{'stu2': 'Bob', 'stu1': 'Jack', 'stu3': 'Mary', 'stu4': 'Kerry'}

#**************删除 **************************
del info["stu1"]                        # 删除 del
print(info)
#{'stu2': 'Bob', 'stu3': 'Mary', 'stu4': 'Kerry'}
info.pop("stu2")                        #删除 pop()， 建议使用
print(info)
#{'stu3': 'Mary', 'stu4': 'Kerry'}
info.popitem()                           #删除 popitem(), 随机删除，不建议使用
print(info)
#{'stu3': 'Mary'}

多级字典嵌套及操作

#***************多级字典嵌套******************
Earth = {
           "Asia":{
                    "China" : ["Beijign","Shanghai"],
                    "Japan" : ["Tokyo","Osaka"]
            },
           "Europe":{
                    "France" : ["Paris","Lyons"],
                    "England":"London"
            },
            "North America":{
                    "America":["Washington","New York"],
                    "Canada" :"Ottawa"
            }
           }
print(Earth["Asia"]["China"])
#['Beijign', 'Shanghai']
Earth["Asia"]["India"] = "New Delhi"
print(Earth["Asia"])
#{'China': ['Beijign', 'Shanghai'], 'India': 'New Delhi', 'Japan': ['Tokyo', 'Osaka']}

遍历字典

#***************************字典的循环***********************************
info = {
    "stu1" : "Jack",
    "stu2" : "Bob",
    "stu3" : "Adam"
}
for i in info:                #比下面循环高效，通过键值来查找
    print(i,info[i])
# stu3 Adam
# stu1 Jack
# stu2 Bob

for k,v in info.items():
    print(k,v)

字典的其他用法

#******************* 字典其他用法***************************
info = {
    "stu1" : "Jack",
    "stu2" : "Bob",
    "stu3" : "Adam"
}
b = {
       "stu8" : "A",
       "stu1" : "B"
}
#******************* values()  *******************
print(list(info.values()))    #以列表返回字典中的所有值
#['Adam', 'Jack', 'Bob']

#******************* keys()  *******************
print(list(info.keys()))    #以列表返回字典中的key
#['stu1', 'stu3', 'stu2']

#******************* setdefault()  *******************
info.setdefault("stu4","Mary")      #如果键不存在于字典中，将会添加键并将值设为默认值
print(info)
#{'stu3': 'Adam', 'stu2': 'Bob', 'stu4': 'Mary', 'stu1': 'Jack'}

info.setdefault("stu1","Kelly")     #如果字典中包含有给定键，则返回该键对应的值，否则返回为该键设置的值
print(info.setdefault("stu1","Kelly") )
#Jack
print(info)
{'stu3': 'Adam', 'stu2': 'Bob', 'stu4': 'Mary', 'stu1': 'Jack'}

#******************* update() *************************
info.update(b)                 #把字典b中的信息更新到字典info中，区别setdefault
print(info)                    #相当于合并字典，info有的元素就更新，没有的元素就添加
#{'stu3': 'Adam', 'stu8': 'A', 'stu2': 'Bob', 'stu1': 'B'}

#******************* items() *************************   以列表返回可遍历的(键, 值) 元组数组
print(info.items())               #将字典转化为列表，可用list()序列化
#dict_items([('stu8', 'A'), ('stu1', 'B'), ('stu2', 'Bob'), ('stu3', 'Adam')])

#******************* fromkeys() *************************
c = dict.fromkeys([6,7,8],[1,{"name":"Jack"},123])        #创建一个新的字典，（键：值）
print(c)
#{8: [1, {'name': 'Jack'}, 123], 6: [1, {'name': 'Jack'}, 123], 7: [1, {'name': 'Jack'}, 123]}

c[7][1]["name"] = "Bob"            #注意内存中数据的变化，参考深浅copy
print(c)
#{8: [1, {'name': 'Bob'}, 123], 6: [1, {'name': 'Bob'}, 123], 7: [1, {'name': 'Bob'}, 123]}

集合set

集合是一个无序不重复的序列。可以用来去重，把一个列表变成集合，就自动去重了。关系测试，测试两组数据之前的交集、差集、并集等关系。

l=[1,2,3,4,3,2,5]
print(l)         # [1, 2, 3, 4, 3, 2, 5]
n = set(l)
print(n)         # {1, 2, 3, 4, 5}

#交集
l=set([1,2,3,4])
m=set([3,4,5,6])
print(l.intersection(m))   # {3, 4}
# 并集
print(l.union(m))    # {1, 2, 3, 4, 5, 6}
# 差集
print(l.difference(m))   # {1, 2}
# 子集
print(l.issubset(m))  # False
# 对称差集
print(l.symmetric_difference(m))   # {1, 2, 5, 6}
# 用于判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。。
print(l.isdisjoint(m))  # False

其他操作

s = set([3,5,9,10])      #创建一个数值集合
t = set("Hello")         #创建一个唯一字符的集合  

a = t | s          # t 和 s的并集  

b = t & s          # t 和 s的交集  

c = t – s          # 求差集（项在t中，但不在s中）  

d = t ^ s          # 对称差集（项在t或s中，但不会同时出现在二者中）  

t.add('x')            # 添加一项  

s.update([10,37,42])  # 在s中添加多项  

使用remove()可以删除一项：  

t.remove('H')  

len(s)
set 的长度  

x in s
测试 x 是否是 s 的成员  

x not in s
测试 x 是否不是 s 的成员  

s.issubset(t)
s <= t
测试是否 s 中的每一个元素都在 t 中  

s.issuperset(t)
s >= t
测试是否 t 中的每一个元素都在 s 中  

s.union(t)
s | t
返回一个新的 set 包含 s 和 t 中的每一个元素  

s.intersection(t)
s & t
返回一个新的 set 包含 s 和 t 中的公共元素  

s.difference(t)
s - t
返回一个新的 set 包含 s 中有但是 t 中没有的元素  

s.symmetric_difference(t)
s ^ t
返回一个新的 set 包含 s 和 t 中不重复的元素  

s.copy()
返回 set “s”的一个浅复制

---