Python学习笔记二(数据类型)

一、数字

  主要包括整形和浮点型,为不可变类型。

  整型:定义方式为num = 1

  浮点型:定义方式height = 179.9

二、字符串

  在单引号、双引号或三引号中,由一串字符组成,为不可变类型。

  定义方式为name = “xxx”

  主要操作如下:

  1.按索引取值。

s = "hello world"
print(s[1])  #打印字母'e'
print(s[-1])  #打印字母'd'

  2.切片

#切片原则为顾头不顾尾
s = "hello world"
print(s[0:4])    #获取前四个子串,索引算头不算尾从0到3
print(s[::2])   #每次间隔一个字符获取字符串子串
print(s[3:1:-1]) #从索引3开始到索引1以后,倒着输出
print(s[-1::-1])  #所有元素反转输出

  3.长度

s = "hello world"
print(s.__len__())
print(len(s))        #实际仍然是调用的s.__len__()

  4.成员运算in和not in

s = "hello world"
print('w' in s )    #True
print('l' not in s)   #False

  5.移除空白strip

s = "   hello world   "
print(s.strip())    #移除字符串左右的空白
print(s.lstrip())   #移除字符串左侧的空白
print(s.rstrip())   #移除字符串右侧的空白
s = "****abc*******"
print(s.strip('*')) #移除字符串左右的*

  6.切分split

passwd = "test:x:504:501::/home/test:/bin/bash"
print(passwd.split(':')) #将字符串以冒号作为分隔符,分成若干字串放在列表中
print(passwd.split(':',1)) #只分割遇到的第一个分隔符拆分
print(passwd.rsplit(':',1)) #从右侧开始,第一个分隔符拆分

  7.循环

s = "hello world"
#依次打出每个字符
for i in s:
    print(i)
#间隔1个打出字符
for i in range(0,len(s),2):
    print(s[i])

  8.lower,upper,startswith,endswith

s = "hello world"
print(s.upper())  #所有字母大写
print("HELLO".lower())  #所有字母小写
print(s.startswith('hello'))
print(s.endswith('world'))
print(s.endswith('d'))

  9.format

print('my name is {},my age is {}'.format('xxx',99))
print('my name is {1},my age is {0}'.format(99,'xxx'))
print('my name is {name},my age is {age}'.format(age=99,name="xxx"))

  10.join

l = ['a','b','c','d','e']  #使用join时,列表中所有元素必须是字符串
print('*'.join(l))
print(''.join(l))

  11.replace

s = 'hello world'
print(s.replace('o','@'))
print(s.replace('o','@',1))  #只替换第一个

  12.isdigit

a = "sljfljjlkjsdfl33"
for i in a:
    print(i.isdigit())   #只有循环到最后两个字符时打印True

三、列表

  1.按索引取值。  

l = ['a','b','c','d']
print(l[2])   #打印第三个元素c
print(l[-2])   #打印倒数第二个元素c

  2.切片

#切片原则是骨头不顾尾
l = ['a','b','c','d',1,2,3,4]
print(l[0:4])    #获取前四个元素,索引算头不算尾从0到3
print(l[::2])   #每次间隔一个获取列表元素
print(l[3:1:-1]) #从索引3开始到索引1以后,倒着输出
print(l[-1::-1])  #所有元素反转输出

  3.长度len

l = ['a','b','c','d',1,2,3,4]
print(l.__len__())
print(len(l))        #实际仍然是调用的l.__len__()

  4.成员运算in和not in

l = ['a','b','c','d',1,2,3,4]
print('c' in l )    #True
print(1 not in l)   #False

   5.追加

l = ['a','b','c','d',1,2,3,4]
l.append('e')
print(l)

  6.删除

#del和remove为单纯的删除,pop为获取删除的元素
l = ['a','b','c','d',1,2,3,4]
del l[7]   #删除最后一个元素
print(l)
l.remove('a')  #删除元素'a'
print(l.pop())  #删除并获取最后一个元素
print(l.pop(2))  #删除并获取第三个元素

  7.循环

l = ['a','b','c','d',1,2,3,4]
for i in l:
    print(i)
for i in range(len(l)):
    print(l[i])

  8.反转和排序  

#排序是元素必须是字符串类型
l = ['a','e','X','8','q','n','ww','EE','3']
l.reverse()  #反转列表
print(l)
l.sort()     #正向排序
print(l)
l.sort(reverse=True)   #反向排序
print(l)

  9.其他方法

l = ['a','b','c','d',1,2,3,4]
l.insert(2,'xx')  #在第三个索引位置插入一个字符串
print(l)
l1 = l.copy()   #拷贝l中所有元素
print(l1)
print(id(l),id(l1))  #列表ID不同
l.clear()       #清空列表内的所有元素
print(l)
print(l1.count('c'))   #t统计列表中某个元素出现的次数
l2 = ['aa','bb','cc',1,2,'c']
l1.extend(l2)   #扩展l1,将两列表拼接在一起,未去重
print(l1)
print(l1.index('c'))
print(l1.index('yy'))  #传入不存在的元素时会报错

 四、元组

  元组中可以存多个值,但不可对元组进行增加和删除操作。

  1.取值 

#按照索引取值
t = ('a','e','X','8','q','n','ww','EE','3')
print(t[4])

  2.切片

#顾首不顾尾,同列表和字符串
t = ('a','e','X','8','q','n','ww','EE','3')
print(t[2:5])
print(t[-1::-1])

  3.长度

#顾首不顾尾,同列表和字符串
t = ('a','e','X','8','q','n','ww','EE','3')
print(len(t))

  4.长度和成员运算

t = ('a','e','X','8','q','n','ww','EE','3')
print(len(t))
print('ww' in t)
print('EE' not in t)

  5.循环

t = ('a','e','X','8','q','n','ww','EE','3')
for i in t:
    print(i)
for i in range(len(t)):
    print(t[i])

  5.index和count

t = ('a','e','X','8','q','n','e','ww','EE','3')
print(t.index('q'))
print(t.index('aaa'))   #不存在就报错
print(t.count('e'))

 五、字典

  字典中可以存多个值,使用key-value来存取,速度快。其中key必须为不可变类型,如数字、字符串、元组等,值可以为任意类型。

  1.存取

info={'name':'xxx','age':99,'sex':'male'}
print(info['age'])
info['hobby'] = 'basketball'
print(info)

  2.长度和成员运算

info={'name':'xxx','age':99,'sex':'male'}
print(len(info))  #返回key的个数
print('name' in info)
print('xxx' in info)  #返回False,说明in只能判断key是否在字典中,不能判断value
print('male' not in info) #返回True

  3.删除

info={'name':'xxx','age':99,'sex':'male'}
del info['name']
print(info)
print(info.pop('age'))  #删除键值对,并返回key对应的值
print(info.popitem())   #随机删除一个键值对,并用元组返回键值对

  4.keys,values,items

info={'name':'xxx','age':99,'sex':'male','hobby':'basketball'}
print(info.keys())  #返回字典的key对象,可用于循环中的遍历
print(list(info.keys()))  #转换为包含所有key的列表
print(info.values())    #同上,返回所有值
print(info.items())     #同上,返回所有键值对

  5.循环

info={'name':'xxx','age':99,'sex':'male','hobby':'basketball'}
for key in info:
    print(info[key])

  6.setdefault

#若key存在,则不赋值,若key不存在则设置默认值
info={'name':'xxx','age':99,'sex':'male','hobby':'basketball'}
info.setdefault('age',33)  #不会修改age的值
print(info)
info.setdefault('country','China') #country不存在,则添加该键值对
print(info)

六、集合

  集合可以包含多个元素,使用逗号分隔,所有元素必须为不可变类型,元素无序且不可重复。主要作用是进行关系运算。

  1.集合创建

a = {3,"aaa",'xxx',222,"as",'EE',3}
print(a)   #自动去重并改变顺序

  2.长度和成员运算

a = {3,"aaa",'xxx',222,"as",'EE',3}
print(len(a))
print(222 in a)
print('EE' not in a)

  3.合集 |

a = {3,"aaa",'xxx',222,"as",'EE',3}
b = {'ff','bbb',3,'EE',44}
print(a|b)

  4.交集 &

a = {3,"aaa",'xxx',222,"as",'EE',3}
b = {'ff','bbb',3,'EE',44}
print(a&b)

  5.差集  -

a = {3,"aaa",'xxx',222,"as",'EE',3}
b = {'ff','bbb',3,'EE',44}
print(a-b)  #在a中不在b中

  6.对称差集 ^

a = {3,"aaa",'xxx',222,"as",'EE',3}
b = {'ff','bbb',3,'EE',44}
print(a^b)  #只在a中或只在b中的所有元素

  7.==

a = {3,"aaa",'xxx',222,"as",'EE',3}
b = {'ff','bbb',3,'EE',44}print(a==b)  #a和b元素不同,返回False

  8.父集和子集

a = {3,"aaa",'xxx',222,"as",'EE',3}
b = {3,'EE'}
print(a>b)  #a是b的父集,返回True
print(a>=b)
print(b<a)  #b是a的子集,返回True
print(b<=a)

 七、字符编码

  1.python解释器执行py文件的原理

  第一阶段:python解释器启动,相当于启动了一个文本编辑器。

  第二阶段:python解释器相当于文本编辑器去打开py文件,将硬盘上的py文件读入内存(python的解释性决定了解释器只关心内容不关心后缀)

  第三阶段:python解释器解释执行加载到内存中的py代码(此阶段才会识别python语法,执行文件中的代码,当执行到赋值语句时,会开辟内存空间存放变量)

  2.常见编码

  ASCII是最早的字符编码,最多只能用8位来表示英文字母、数字和特殊字符,即2**8=256个符号。

  unicode常用2个字节代表一个字符,生僻字使用4个字节。内存中统一采用unicode,浪费空间来换取可以转换成任意编码(不乱码),硬盘可以采用各种编码,如utf-8,保证存放于硬盘或者基于网络传 输的数据量很小,提高传输效率与稳定性。

  UTF-8将一个unicode字符根据不同的数字大小编码成1-6个字节,常用的英文字母被编码成1个字节,汉字通常是3个字节,只有生僻的字符才会被编码成4-6个字节。UTF-8可以节省空间。

  3.不乱码的法则

  保证不乱码的核心法则是,字符按照什么标准而编码的,就要按照什么标准解码。内存中写的所有字符,都是unicode编码。

  第二阶段中,使用 #coding:utf-8 来决定以什么编码格式将源码读入内存。

  第三阶段中,使用 #coding:utf-8来决定字符串在内存中使用的编码方式。使用print输出时,终端编码必须和#coding那块一致,window终端默认为GBK,若使用unicode格式数据,无论怎么打印都不会乱码。

  4.编码总结

  python2中的str类型就是python3中的bytes类型。

 八、文件处理

  文件读取操作

#打开文件,得到文件句柄并赋值给变量
f = open('a.txt','r',encoding='utf-8')   文件保存时使用utf-8,则需用utf-8解码。
data = f.read()
f.close()

  若不想使用f.close(),可使用with关键字

with open('a.txt','r') as f:
    pass
with open('a.txt','r') as read_f,open('b.txt','w') as write_f:
    data = read_f.read()
    write_f.write(data)

 

posted @ 2018-01-11 23:17  n1ghtwatcher  阅读(257)  评论(0编辑  收藏  举报