python学习全记录（5）数据类型及内置方法

基本数据类型及内置方法
一、列表类型[ ]
定义列表：
l1 = [1,3.14,5+4j,True,’abc’,[[1]]]
print(l1)
输出结果：[1, 3.14, (5+4j), True, ‘abc’, [[1]]]

l2 = list([1,3.14,5+4j,True,’abc’,[[1]]])
print(l2)
输出结果：[1, 3.14, (5+4j), True, 'abc', [[1]]]

l3 = list(‘abc’)
print(l3)
输出结果：['a', 'b', 'c']

注：列表里可以存储整型、浮点型、复数、bool型、字符串、列表

   1、字符串<=>列表
将字符串转换为列表：字符串方法
l4 = ‘hello world’.split(‘ ‘)
print(l4)
输出结果：['hello', ‘world']

      将列表转换为字符串：字符串方法，调用方法的字符串为拼接字符串的依据。
将列表中的所有数据，从前往后，安装拼接符进行拼接。
newStr = ‘@‘.join(l4)
print(newStr)
输出结果：hello@world

   2、切片
list3 = [1,2,3,4,5]
print(list3[1:-1:2])    #语法：[开始索引位置：末尾索引位置：步长]，尾部第一个为-1
输出结果：[2, 4]
list3 = [1,2,3,4,5]
print(list3[0:-1:2])
输出结果：[1, 3]

   3、增删改查
删除普通变量:
a=10 
del a
print(a)
输出结果：报错，因为a的赋值已经被删除，没有什么可以输出的

增：append(obj)  在末尾添加对象
list4 = [ ]
print(id(list4))
list4.append(1)
list4.append(5)
list4.append(2)
print(list4)
输出结果：[1, 5, 2]     #证明列表是可变类型，在id不变的情况下可以修改内部数据

插入：
list4.insert(0,10)      # 语法：（插入位置，插入的值）
print(list4)
输出结果：[10, 1, 5, 2]

删：
	删除指定索引                                     删除指定对象   
	del list4[0]                                          list4.remove(5)
	print(list4)				     print(list4)
	输出结果：[1, 5, 2]			     输出结果[1, 2]

改：
list4[0] = 10000
print(list4)
输出结果：[10000, 2]

查：  print(list4[1])
输出结果：2

   4、长度
list4.append(88888)
print(len(list4))               # list4:[10000,2,88888]
输出结果：3	

   5、成员运算    in和not in(同步出现，中间尽量不要有其他值)
print(2 in list4)
输出结果：True

   6、循环：迭代
list7 = [1,3,5,7,0]

for obj in list7:
	print(obj,end=‘,’)
输出结果：1,3,5,7,0,

       需求：打印1，3，5，7，0
		sss = “”	#给出的是列表，最终输出的是字符串
		for obj in list7:
			sss += str(obj) + ‘,’     #obj是int类型，不能直接做字符串拼接，转化成字符串
		print(‘>>>’,sss[:-1])
		输出结果：>>> 1,3,5,7,0

    7、翻转
a = [1,3,2]
a.reverse()
print(a)
输出结果：[2, 3, 1]
   
    8、排序：前提：数据之间全部具有可比性；数据要统一类型
b=[1,3,2,5,4]
b.sort()
print(b)
输出结果：[1, 2, 3, 4, 5]

倒序
b.reverse()
print(b)
b.sort(reverse=True)
print(b)
输出结果：[5, 4, 3, 2, 1]
	        [5, 4, 3, 2, 1]

9、copy:复制
10、clear:清空
11、count:计算成员个数
12、extend:添加多个值（参数为可迭代对象：可被for循环的，str、list、dict、tuple、set、range生成的对象）
13、index:查找索引
x = [1,3,5,3]
y = x
print(x,id(x))
print(y,id(y))
输出结果：[1, 3, 5, 3] 4480132488
[1, 3, 5, 3] 4480132488
z=x.copy() # 开辟新的内存空间
print(z,id(z))
输出结果：[1, 3, 5, 3] 4480132552

x[0]=10000
print(x[0])
print(y[0])
print(z[0])
输出结果：10000
	        10000
	        1

z.clear()
print(z)
输出结果：[ ]

print(x.count(3))   
输出结果：2

list1 = [ ]
list1.extend(‘abc’)
print(list1)     
输出结果：['a', 'b', ‘c']

list2 = [‘abc’,’xyz’]
list1.extend(list2)
print(list1)
输出结果：['a', 'b', 'c', 'abc', ‘xyz']

列表总结：
1、列表中可以存放多个值
2、列表为可变类型：id不变的情况下，可以发生值变化
3、列表为有序存储结构：可以通过索引取值

二、字符串类型str
声明：
s1 = ‘字符串’
ss1 = “字符串”
sss1 = “””字符串“”“ #多行字符串

# 小张是个好学生
print(‘小张是个“好学生”’)     #利用字符串嵌套来完成有引导的字符串输出
print(“小张是个’好学生’”)
#  \’   |   \” 该单、双引号只有在输出时才会被转化为’  |  “
print(“””’小张’是个“好学生\”””)
输出结果：小张是个"好学生"
	        小张是个'好学生'
	       ‘小张'是个"好学生"

ssss1 = str(‘字符串’)
print(ssss1)
输出结果：字符串

   1、字符串索引（从0开始编号）取值
s2 = ‘abc123嘿嘿嘿’
print(s2[3])    #正向索引，从0开始编号
print(s2[-3])   #反向索引，从-1开始编号
输出结果：1
	        3

    2、切片（获取子字符串）         语法[开始索引：结束索引：步长]
 #顾头不顾尾[6:8],从索引6截取到索引8之前
ss2 = ‘hello world’  
new_ss2 = ss2[6:8:]
print(new_ss2)
输出结果：wo

结束索引：-1代表截取到最后一位之前，省略代表截取到最后
开始索引：省略代表从头开始截取
print(ss2[6:-1:])
输出结果：worl

截取一次只截取一个字符，但是截取后迈2步截取下一个
print(ss2[::2])
输出结果：hlowrd

打印’dlrow olleh’,翻转字符串
步长为负数时，从后往前截取（开始索引建议使用负值）
print(ss2[-1::-1])
输出结果：dlrow olleh

重点：s[开始索引：结束索引]

    3、长度
s3 = ‘abcdef’
print(s3.__len__())
print(len(s3))     #len(s)获取s的字符长度
输出结果：6
	       6
     
    4、拆分
s4 = “D:\\pathon36\\python3.exe”
需求：1、获取python的安装盘符；2、获取python的执行文件
s4_list = s4.split(‘\\’)      #拆分，就是将字符串转化为列表
print(s4_list)         输出结果：['D:', 'pathon36', 'python3.exe']
print(s4_list[0])     输出结果：D:
print(s4_list[-1])    输出结果：python3.exe
完成上述需求还要保证拆分得到的结果尽可能短
注：拆分的依据，拆分的次数

s4_list = s4.split(‘\\’,1)
print(s4_list[0])
输出结果：D:

    5、成员判断
s5 = ‘abc123嘿嘿嘿’
# in | not in:子字符串 in 父字符串
print(‘abcd’ in s5)       输出结果：False
print(‘abc’ not in s5)     输出结果：False
print(‘呵呵’ not in s5)     输出结果：True

not in 要同步出现
    
    6、首尾去白
s6 = “  hello world  “
print(s6.strip())
输出结果：hello world

    7、数字判断
num = input(“请输入：”)
if num.isdigit( ):
	num = int(num)
	print(num)
else:
	print(“请输入数字”)

需求：只有输入数字才允许通过，否则要重复输入
reStr  = ‘ ’
while True:
	num = input(“请%s输入：” % reStr)
	if num.isdigit( ):
		num = int(num)
		print(num)
		break
	else:
		print(“请输入数字”)
		reStr = “再次”
需求：错误三次也退出
reStr = ‘ ’
count = 1
while True:
	num =input(“请%s输入：” % reStr)
	if num.isdigit( ):
		num = int(num)
		print(num)
		break
	elif count >=3:
		print(“错误次数过多”)
	else:
		print(“请输入数字”)	
		reStr = “再次”
		count +=1	

三、字符串循环（遍历）
i = 0
while i<len(s):
print(s[i])
i +=1
输出结果：h
e
l
l
o

                        w
                        o
                        r
                        l
                       d

迭代
for c in s:
	print(c)
输出结果：h
	       e
	       l
	       l
	       o

                        w
                        o
                         r
                         l
                        d

总结：1、循环迭代s，一次在s中取出一个字符，存放到c中；
2、下一次取出会覆盖上一次c；
3、当s中所有字符取出后，循环自动停止。

可以被迭代的对象：str、list、dict、tuple、set、range生成的对象
iterable：可迭代对象

print(rang(5))
从什么数字开始，到什么数字前结束，步长是多少
for i in range(1,5,2):
print(i)
输出结果：1
3

For i in range(10,16):
print(i)
输出结果：10
11
12
13
14
15

四、字符串内置方法
1、lstrip | strip: 左 | 右 去留白
s1 = “ hello world ”
print(s1.rstrip())
输出结果： hello world

ss1 = “===hello  world***”
print(ss1.lstrip(“=”))
print(ss1.rstrip(“*”))
输出结果：hello  world***
	       ===hello  world

  2、rsplit:从右开始拆分，拆分成列表
s4 = “D:\\python36\\python.exe”
s4_list = s4.rsplit(‘\\’,1)
print(s4_list)
输出结果：['D:\\pathon36', ‘python3.exe']

   3、lower   |    lower :  全小   |    大写
print(“AbCd”.lower())
print(“AbCd”.upper())
输出结果：abcd
	       ABCD

    4、startswith | endswith：以某某开头 | 结尾：返回值为bool类型
print(“http://www.baidu.com”.startswith('https://'))
print(“http://www.baidu.com”.endswith('com'))
输出结果: False
	      True

    5、format : 格式化{  }
print(‘name:%s,age:%s’ % (‘owen’,18))
输出结果：name:owen，age:18

占位与实际数据要进行个数与位置的匹配
print(‘name:{ },age:{ }’.format(‘Owen’,8))
输出结果：name:Owen，age:8

指定位置要数据：{0}要0号位数据
print(‘name:{0},age:{1},name:{0}’.format(‘Owen’,58))
输出结果：name:Owen，age:58, name:Owen

指定名字要数据
print(‘name:{usr},age:{age},name:{usr}’.format(age=58,usr=‘Owen’))

6、replace:替换
语法：replace(oldS,newS,count)
s6 = ‘abcabcabc’
newS6 = s6.replace(‘a’,’A’,2)
print(newS6)
输出结果：AbcAbcabc

7、find   |   rfind ： 查找子字符串索引，无结果返回-1
s1 = ‘abcabc’
print(s1.rfind(‘ab’))   #返回第一次查询到的（目标值） 
输出结果：3
rfind是往后找找到最后一个要找的位置

8、index | rindex：查找子字符串索引，无结果抛出异常
print(s1.index(‘cb’))        输出结果：异常崩溃报错

9、count:计算子字符串个数
print(s1.count(‘abc’))       输出结果：2

10、center | ljust | rjust | zfill：按位填充
        语法：center(所占位数, '填充符号')
        使用： 调用者.center(参数)
  print(“华丽分割线”.center(10,’-’))
  print(“华丽分割线”.ljust(30,’-’))
  print(“华丽分割线”.rjust(30,’-’))
  print(“1240”.zfill(5))
  print(“9010”.zfill(5))
  print(“59000”.zfill(5))
  输出结果：------------华丽分割线-------------
	         华丽分割线-------------------------
	          -------------------------华丽分割线
	          01240
	          09010
	          59000

11、expandtabs：规定\t所占空格数
print(‘hello\tworld’.expandtabs(5))
输出结果：hello     world

12、captialize | title | swapcase：首字母大写 | 单词首字母大写 | 大小写反转
print(“hello world”.capitalize())
print(“hello world”.title())
print(“hello WORLD”.swapcase())
输出结果：Hello world
	        Hello World
	        HELLO world

13、isdigit | isdecimal | isnumeric：数字判断
s7 = b’123’       # isdigit来判断是否可以转换为数字
print(b’123’.isdigit())   输出结果： True

print(u’123’.isdecimal())   输出结果： True
print(u’123’.isnumeric())   输出结果： True
print(u’123’.isdigit())          输出结果：True

print(‘肆’.isdigit())	     输出结果： False
print(‘肆’.isdecimal())     输出结果： False
print(‘肆’.isnumeric())     输出结果： True     # isnumeric可以判断中文数字

print(‘IV’.isdigit())	输出结果： False
print(‘IV’.isdecimal()) 输出结果： False
print(‘IV’.isnumeric()) 输出结果： True      # isnumeric可以判断罗马数字

14、isalnum | isalpha：是否由字母数字组成 | 由字母组成
print(‘abc123_’.isalnum())	输出结果：False
print(‘abc’.isalpha())		输出结果：True

15. islower | isupper：是否全小 | 大写
print(“aBc”.islower())    输出结果：False

16. isidentifier：是否为合法变量名
print(‘>>>’,’a_123’.isidentifier())     输出结果：True

17. isspace：是否是空白字符
print(“ ”.isspace())       输出结果：True

18. istitle：是否为单词首字母大写格式
print(“Hello World”.istitle())      输出结果：True

五、元组tuple( )
定义：t1= ( )
t = (1,2,3)
t = (1, )

   参数为for可以循环的对象（可迭代对象）
t2 = tuple(“123”)    输出结果：('1', '2', '3') <class 'tuple'>
t3 = tuple([1,2,3])    输出结果：(1, 2, 3) <class 'tuple'>
t4 = tuple((7,8,9))    输出结果：(7, 8, 9) <class 'tuple'>

    定义只有一个值的元组
print((“Owen”,  ))	输出结果：('Owen',)
print(tuple([‘Owen’]))		输出结果：(‘Owen',)   # 因为元组不可变，所以将Owen放入列表，用tuple强制转换成元组
print(tuple(‘owen’))	输出结果：('o', 'w', 'e', 'n')

常用操作：元组有序存储
1、索引取值（索引取值取有序值）
t = (1,2,3,2,3,2)
print(t[1])	输出结果：2
print(t[-2])	输出结果：3

2、切片
print(id(t))
nt = t[:-1:]
print(nt,id(nt))
输出结果：4326421608
	       (1, 2, 3, 2, 3) 4416873928    # id改变，说明元组是不可变类型的

3、长度（item元素个数）
print(len(t))	输出结果：6	

   	4、元组内置方法
print(t.count(2))    输出结果：3      #该数据集合可以存放相同数据，括号内指的是统计哪个数
print(t.index(2,2,3)) 	输出结果：  # 语法：index(要查找的元素，首地址，尾地址)索引输出的是位置

元组的案例：
案例一、
提前拥有一个老师列表，打算开除，如果是校长、亲友团免开
原始列表为list类型
手动输入是否是亲友团，决定是否能开除（）
分析：判断是否为亲友团，如果是亲友团，则将list类型转换为元组类型
Teas =[‘Bob’,’Alex’]
Friends = input(“亲友团[0,1]:”)

If friends == ‘1’:
teas = tuple(teas)
Else:
pass

异常处理：判断teas对象是否是tuple类型

If isinstance(teas,tuple): #老师是否是亲友团，不是就开除
teas.clear( )
For t in teas:
print(‘在职老师：%s’ % t)

案例二、
元组中的数据一定不能改变，但是元组中的数据（可变类型）的数据可以改变
T1 = (1,2,”abc”,True,(1,2)) # t1永远无法改变
T2 = (1,2,[ ])
print(t2,type(t2),id(t2),id(t2[2]))
t2[2].extend(10,20) # extend是把元组追加到列表
print(t2,type(t2),id(t2),id(t2[2]))
输出结果：(1, 2, []) <class ‘tuple’> 4480402128 4474191688
(1, 2, [10, 20]) <class ‘tuple’> 4480402128 4474191688

六、字典
字典的定义：{} | dict() # dict用在强制转换时
字典的常用操作：增删改查
字典的内置方法：
字典的循环（迭代）

特别了解：dict是python中仅存的mapping类型
1、声明
dict的key，可以为所有不可变类型：int float tuple str bool None，一般就采用字符串
dict的value：可以为所有数据类型
注：key具有唯一性（重复会覆盖旧值），value可以重复
 强制转化为字典:
  1、d1 = {'name': 'owen', 'age': 12}
 print(d1)

   2、d2 = dict({'name': 'owen', 'age': 12})
  print(d1)

   3、d3 = dict(name='owen', age=12)
  print(d3)

    字典无序存储数据，无索引与切片，用key来取值

  2、增删改查
dic={}
# 增：key不存在
dic['name'] ='bigowen'  # 用key增加
print(dic)
# 改：key已存在
dic['name'] = 'owen'  # key具有唯一性，重复会覆盖旧值
print(dic)
# 查
print(dic['name'])  # 查找key值
# 删 (字典中无remove操作)
del dic['name']
print(dic)    # 返回空字典
print(dic.clear())   #返回None

3、get取值 *****
dic={‘a’:10,‘b’:20}
print(dic[‘c’]) # 报错，keyerror
res= dic.get(‘c’) #拥有默认值，None，可以避免错误

print(res)

res = dic.get(‘d’,‘key不存在’) # 如果key不存在，则自定义默认值"key不存在"
print(res)

增（更新）:添加的参数字典，与dic重复，就是更新值，新key就是新增
dic.update({‘a’:1000,‘c’:300}) #如果存在就覆盖，若不存在就添加
print(dic)

删**
res = dic.pop(‘c’) # 根据key删除指定对象，并返回删除对象的value,若没找到关键字则报错
print(res)

复制（浅拷贝/深拷贝）
newDic = dic.copy()
print(newDic)

d1={‘list’:[1,2]}
d2 = d1.copy()
print(id(d1),id(d1[‘list’])) # 4398858104 4307050312
print(id(d2),id(d2[‘list’])) # 4398895320 4307050312
d1[‘list’].append(‘abc’) # 追加
print(d2)
浅copy：只做第一层copy，内部的成员地址还是原来的地址

popitem 随机删除、返回值是被删除的（key,value）
dic = {‘a’:100,‘b’:200,‘c’:300,‘d’:400}
print(dic)
print(dic.popitem()) #返回被随机删除的key,value
print(dic.popitem())
print(dic) # 打印剩下的

如何定义一个空字典：
第一个参数：keys:list|tuple|str,第二个参数：统一的默认value
d10 = {}.fromkeys([‘a’,‘b’,‘c’],’’)
print(d10) # {‘a’: ‘’, ‘b’: ‘’, ‘c’: ‘’}

独自设置默认值
d11={‘a’:10,‘teas’:[‘owen’]}
d11 = {‘a’:10}

添加老师
如果有teas，在原teas基础上添加老师，如果没有，新建一个空teas
if ‘teas’ not in d11: # 成员运算
d11[‘teas’] = []
d11[‘teas’].append(‘Egon’)
d11[‘teas’].append(‘Liuxx’)
print(d11)

原d11中，如果有teas这个key,setdefault相当于什么都没干
如果没有，就将第二个参数（默认值）传给teas存放到d11中
d11.setdefault(‘teas’,[])
d11[‘teas’].append(‘Egon’)
d11[‘teas’].append(‘Liuxx’)
print(d11)

4、字典循环
dic = {‘a’:10,‘b’:20,‘c’:30}
直接for循环（遍历）字典得到的是key
for k in dic:
print(k,dic[k])

 能只循环值
values = dic.values()
print(values,type(values))
存放key的集合
keys = dic.keys()
print(keys,type(keys))
 存放key-value的键值对关系
k_vs = dic.items()
print(k_vs,type(k_vs))

 dic.values() | dic keys() | dic.items() 不是原生list,不能直接索引取值，但可以for循环取值
vs = list(values)  # 把values放入列表中，通过列表取值
print(vs[1])
for v in vs:
		print(v)

for k in keys:  # 跟直接遍历字典是一样的
		print(k)

*****同时遍历k-v
for k,v in dic.items():
print(k,v)

案例：不区分大小写，计算每一个名字出现的次数，记录在字典中
ls = [‘Owen’,‘owen’,‘Egon’,‘Liuxx’,‘LiuXX’,‘egon’,‘egon’]
name_dic = {}
for name in ls:
名字全小写，不用区分大小写
name = name.lower()
名字是否在字典中存在：存在 - 次数+1 |不存在 - 添加并设置初值1
if name not in name_dic:
name_dic[name] = 1
else:
name_dic[name] +=1
print(name_dic)

name_dic={}
for name in ls:
name = name.lower()
name已经存在，不管，不存在，初始化指定key：name值为1
name_dic.setdefault(name,0)
name_dic[name] +=1
print(name_dic)