python基础之二

1. 数据类型

1.1 数字

数字的作用：与数字相关，例如：手机号、QQ号、身份证号等，用数字表示

数字分为：整数(int)、浮点数(float)、复数(了解)

例子：

age = 10
print(type(age))
salary = 5680.85
print(type(salary)) 

长整型和复数，了解即可

长整型：在pyhton2中使用，在python3已经废弃掉

复数：

x = 1 - 2j        # 定义
print(x.real)     # 获取实部
print(x.imag)     # 获取虚部

整数分为：二进制、八进制、十进制、十六进制等

进制之间可以相互转换，例如：

age = 10  # age=int(10)
print(bin(age))  # 十进制转化为二进制
print(oct(age))  # 十进制转化为八进制
print(hex(age))  # 十进制转化为十六进制

1.2 字符串

作用：定义名字、地址、国籍等描述性信息

定义：在单引号、双引号、三引号内由一串字符组成；字符串，本身存储一个值，由一串字符组成。

常用操作有：

移除空白

切分

长度

索引

切片

1.2.1 移除空白

移除空白的方法是strip，例如：

msg='    welcome to beijing     '
print(msg.strip())   # 移除左右两侧空白
print(msg.rstrip())  # 移除右侧空白
print(msg.lstrip())  # 移除左侧空白

运行结果：

welcome to beijing
    welcome to beijing
welcome to beijing    

移除指定字符，比如移除指定字符’*’，例如：

msg='******python******'
print(msg.strip('*'))
print(msg.lstrip('*'))
print(msg.rstrip('*'))

运行结果：

python
python******
******python 

1.2.2 切分

字符串切分，通过制定切分字符，进行切分，切分的结果是一个列表，例如：

user_info='root:x:0:0::/root:/bin/bash'
user_list=user_info.split(':')
print(user_list)

运行结果：

['root', 'x', '', '', '', '/root', '/bin/bash'] 

指定切分次数进行字符串切分，例如：

cmd_info='get|sys.log|error'
cmd_list=cmd_info.split('|',1)
print(cmd_list)

运行结果：

['get', 'sys.log|error']

字符串默认切分分割符空格，例如：

msg='my name is jack '

运行结果：

['my', 'name', 'is', 'jack']

1.2.3长度

统计字符串长度，实际就是统计字符的个数，例如：

msg='hello world'
print(msg.__len__())  # 属于内置方法
print(len(msg))       # 等价于msg.__len__() 

1.2.4 切片

切片，跟下标有关，顾头不顾尾的操作，例如：

msg = 'hello world'
print(msg[1:4])
print(msg[:4])
print(msg[4:])
print(msg[:-1])
print(msg[:])
print(msg[2:7:2])

执行结果：

ell
hell
o world
hello worl
hello world
low

1.2.5 其他操作

1.2.5.1 endswith startswith

startswith 以…开头，判断的结果是True、False

endswith 以…结尾，判断的结果是True、False

例如：

name='alex_SB'
print(name.endswith('SB'))      # 以SB开头，判断成功，显示True
print(name.startswith('alex'))  # 以alex结果，判断成功，显示True 

1.2.5.2 replace

replace字符串的替换，例如：

name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))     # 指定替换次数

1.2.5.3 format

字符串本身提供字符串格式的方法format，例如：

print('{} {} {}'.format('jack',58,'male'))
print('{0} {1} {0}'.format('jack',58,'male'))
print('NAME:{name} AGE:{age} SEX:{sex}'.format(age=58,sex='male',name='jack'))

运行结果：

jack 58 male
jack 58 jack
NAME:jack AGE:58 SEX:male

1.2.5.4 isdigit

判断字符串是否为数据，提供了三种方法isdigit、

num=''
print(num.isdigit()) 

利用isdigit判断是否为数字，进行程序的判断运行

jack_age=73
while True:
    age=input('>>: ').strip()
    if len(age) == 0:continue
    if age.isdigit():
        age=int(age)
        print(age,type(age))

1.2.5.5 find index

name='jack say hello'
print(name.find('o',1,3))   # 顾头不顾尾,找不到则返回-1不会报错,找到了则显示索引
print(name.index('e',2,4))  # 同上,但是找不到会报错
print(name.count('e',1,3))  # 顾头不顾尾,如果不指定范围则查找所有 

1.2.5.6 join

利用join，进行字符串的拼接，内容必须是字符串；否则会类别报错，

l=['jack','say','hello','world'] #类别内容必须都是字符串
print(':'.join(l))
tag=' '
print(tag.join(['jack','say','hello','world'])) #可迭代对象必须都是字符串 

1.2.5.7 填充

利用center方法，进行填充，填充可以指定字符，默认填充字符是空格，例如：

name='jack'
print(name.center(30))
print(name.center(30,'*'))
print(name.ljust(30,'*'))
print(name.rjust(30,'*'))
print(name.zfill(30))

运行结果：

             jack
*************jack*************
jack**************************
**************************jack
00000000000000000000000000jack

1.2.5.8 expandtabs

指定tab键空格数量，默认的tab键是四个空格，例如：

name='jack\thello'
print(name)
print(name.expandtabs(2)) 

1.2.5.9 大小写转换

name='JACK'
print(name.lower())  # 大写转小写
name='jack'
print(name.upper()) # 小写转大写 

1.2.5.10  capitalize swapcase title

name='jack say'
print(name.capitalize()) # 首字母大写
print(name.swapcase())   # 大小写翻转
msg='jack say hi'
print(msg.title())       # 每个单词的首字母大写
name='jack123'
print(name.isalnum())    # 字符串由字母和数字组成
name='jack'
print(name.isalpha())    # 字符串只由字母组成

运行结果：

Jack say
JACK SAY
Jack Say Hi
True
True 

1.2.5.11 判断数字

利用isdigit判断是否为数字，可以对Bytes、unicode进行数字判断：

num1=b'' #Bytes
num2=u'' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())

运行结果：

True
True
False
False

利用isnumberic进行判断中文和罗马的数字

num1='四' #中文数字
num2='Ⅳ' #罗马数字
print(num1.isnumeric())
print(num2.isnumeric()) 

利用isdecimal进行判断unicode的数字

num1=u'' #unicode,python3中无需加u就是unicode
num2='四' #中文数字
num3='Ⅳ' #罗马数字

#isdecimal:对unicode的数字进行判断
print(num1.isdecimal())  # 结果True
print(num2.isdecimal())  # 结果False
print(num3.isdecimal())  # 结果False

结论：用isdigit基本满足对数字的判断

1.2.5.12 练习题

# 写代码,有如下变量,请按照要求实现每个功能
name = " aleX"
# 1) 移除 name 变量对应的值两边的空格,并输出处理结果
print(name.strip())
# 2) 判断 name 变量对应的值是否以 "al" 开头,并输出结果

print(name.startswith(('al')))
# 3) 判断 name 变量对应的值是否以 "X" 结尾,并输出结果

print(name.endswith('X'))
# 4) 将 name 变量对应的值中的 “l” 替换为 “p”,并输出结果
print(name.replace('l','p'))
# 5) 将 name 变量对应的值根据 “l” 分割,并输出结果。
print(name.split('l'))
# 6) 将 name 变量对应的值变大写,并输出结果

print(name.upper())
# 7) 将 name 变量对应的值变小写,并输出结果

print(name.lower())
# 8) 请输出 name 变量对应的值的第 2 个字符?
print(name[1])
# 9) 请输出 name 变量对应的值的前 3 个字符?
print(name[:3])
# 10)请输出 name 变量对应的值的后 2 个字符?

print(name[-2:])
# 11)请输出 name 变量对应的值中 “e” 所在索引位置?

print(name.find('e'))
# 12)获取子序列,去掉最后一个字符。如: oldboy 则获取 oldbo。
print(name[:-1]) 

1.3 列表

作用：可以存多个值，例如爱好、课程、多个朋友等。

定义：[]内可以有多个任意类型的值，例如：数字、字符串、列表、字典、元组等。

常用操作：

索引

切片

追加

删除

长度

包含

1.3.1 索引

索引，即为下标，与字符串类似；可以通过下标进行访问列表的值，从左往右，按照顺序进行访问，例如：

my_friends=['jack','tom','frank',4,10,30]
print(my_friends[1]) 

1.3.2 切片

从列表中切出子列表，例如：

my_friends=['jack','tom','frank',4,10,30]
print(my_friends[1:5])

运行结果：

['tom', 'frank', 4, 10] 

1.3.3 追加

利用列表的方法append，向列表尾部添加元素，例如：

my_friends=['jack','tom','frank',4,10,30]
my_friends.append('mary')
print(my_friends)

运行结果：

['jack', 'tom', 'frank', 4, 10, 30, 'mary']

1.3.4 删除

列表的删除有pop、remove，具体用法，用例子进行说明，例如：

my_friends=['jack','tom','frank',4,10,30,'mary']
# pop按照索引进行删除
my_friends.pop()   # 从列表尾部删除
my_friends.pop(0)  # 从列表头部删除
my_friends.pop(2)  # 从指定位置删除
print(my_friends)  # 运行结果：['tom', 'frank', 10, 30]

my_friends=['jack','tom','frank',4,10,30,'mary']
#remove按照值进行删除
my_friends.remove('frank') # 删除值为frank
print(my_friends)           # 运行结果：['jack', 'tom', 4, 10, 30, 'mary']

1.3.5 长度

计算列表长度，利用列表的内置方法__len__()进行计算，python也提供了len()方法计算列表长度，例如：

my_friends=['jack','tom','frank',4,10,30,'mary']
print(my_friends.__len__())   # 内置方法__len__() 结果：7
print(len(my_friends))        # 利用方法len()     结果：7 

1.3.6 成员运算，包含(in)

成员运算，主要利用in判断成员是否在列表存在，例如：

my_friends=['jack','tom','frank',4,10,30,'mary']
print('mary' in my_friends)    # 运行结果：True

1.3.7 插入

插入元素，利用insert

my_friends=['jack','tom','frank',4,10,30,'mary']
my_friends.insert(0,'abc')    # 从开始位置插入
my_friends.insert(2,'cat')    # 指定位置插入
print(my_friends) 

1.3.8 其他操作

my_friends=['jack','tom','frank',4,10,30,'mary']
# my_friends.clear()       # 清空列表的值
new_list=my_friends.copy() # copy一个列表
my_friends.count('jack')   # 统计元素在列表中的次数
my_friends.extend(['jack1','jack2','jack3']) # 一次添加多个元素
my_friends.index('tom')   #  查看元素在列表中的下标
my_friends.reverse()      #  列表翻转

1.3.9 模拟队列

#队列：先进先出
fifo=[]
# 入队
fifo.append('first')
fifo.append('second')
fifo.append('third')
# 出队
fifo.pop(0)
fifo.pop(0)
fifo.pop(0)

# 入队
fifo.insert(0,'first')
fifo.insert(0,'second')
fifo.insert(0,'third')
# 出队
fifo.pop()
fifo.pop()
fifo.pop()

1.3.10 模拟堆栈

#堆栈：先进后出
filo=[]
# 入栈
filo.append('first')
filo.append('second')
filo.append('third')
print(filo)
# 出栈
filo.pop()
filo.pop()
filo.pop()

# 入栈
filo.insert(0,'first')
filo.insert(0,'second')
filo.insert(0,'third')
# 出栈
filo.pop(0)
filo.pop(0)
filo.pop(0) 

1.4 元组

作用：存多个值，对比列表来说，元组不可变；主要用来读

特点：不可变，进行读操作，可与列表对比学习

常用操作：

索引

切片

循环

长度

包含in

1.4.1 定义

例如：

age=(11,22,33,44,55,33)# 本质age=tuple((11,22,33,44,55)) 

1.4.2 使用

age=(11,22,33,44,55,33)
print(age[1])        # 按索引取值
print(age[1:4])      # 元组的切片
print(len(age))      # 获取元组的元素个数
print(age.__len__()) # 获取元组的元素个数
print(35 in age)     # 判断元素是否是元组的元素
print(age.count(33)) # 判断元素在元组中的数量
print(age.index(44)) # 获取元素在元组中的索引

1.4.3 练习

简单购物车：

# 实现打印商品详细信息，
# 用户输入商品名和购买个数，
# 则将商品名，价格，购买个数加入购物列表，
# 如果输入为空或其他非法输入则要求用户重新输入

msg_dic={
    'apple':10,
    'tesla':100000,
    'mac':3000,
    'lenovo':30000,
    'chicken':10,
}

goods_list=[]

while True:
    for key in msg_dic:
        print('\033[43mName:{name}\t\tPrice:{price}\033[0m'.format(name=key,price=msg_dic[key]))
    choice=input('pls input your goods>>：')
    if len(choice) == 0 or choice not in msg_dic: continue

    count=input('pls input your number>>:')
    if not count.isdigit(): continue

    goods_list.append((choice,msg_dic[choice],count))
    print(goods_list)

1.5 字典

作用：存多个值，用key-value进行存取，取值方便，速度快

特点：字典的key必须是不可变类型，也成为可hash类型

常用操作：

存/取

删除

键值

长度

循环

包含in

1.5.1 定义

字典的key必须是不可变类型（数字、字符串、元组），值可以是任意类型

定义的方式：

info={'name':jack,'age':18,'sex':'male'}
#本质info=dict({'name':jack,'age':18,'sex':'male'}) 

1.5.2 存/取

# 字典的取值，赋值
info={'name':'jack','age':18,'sex':'male'}
print(info['age'])     # 取值
info['height']=1.80   # 存值

1.5.3 删除

通过字典的pop方法，进行删除；pop方法有两个参数，通过指定key进行删除子点的元素

info={'name':'jack','age':18,'sex':'male'}
print(info.pop('name'))
# print(info)
print(info.pop('tom',None)) 

1.5.4 获取

利用get获取字典的值，如果key不存在，返回None，不报错；例如：

info={'name':'jack','age':18,'sex':'male'}
print(info['name'])                 # key不存在，报错
print(info.get('name'))             # key不存在，返回None
print(info.get('addr','not key'))   # key不存在，返回not key

1.5.5 其他方法

info={'name':'jack','age':18,'sex':'male'}
print(info.popitem())    # 随机删除一个元素
print(info.keys())      # 获取字典所有的key
print(info.values())    # 获取字典所有的value

# 循环字典
for key in info:
    print(key)
for key in info:
    print(key,info[key])

# 字典的items()方法
for key,val in info.items():   # key,val == ('name','jack')
    print(key,val) 

1.5.6 fromkeys

利用fromkeys方法，进行初始化字典

dic=dict.fromkeys(['name','age','sex'],None)
print(dic)
    print(dict([('name', 'jack'), ('age', 18), ('sex', 'male')])) 

2.5.7 update

update用新的字典更新原来字典，如果原来字典没有，直接把新字典添加原来字典

info={'name':'jack','age':18,'sex':'male'}
dic={'a':1,'b':2,'name':'mary','sex':'female'}
info.update(dic)
print(info) 

1.5.8 练习

# 有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，
# 将所有大于 66 的值保存至字典的第一个key中，
# 将小于 66 的值保存至第二个key的值中。
# 即： {'k1': 大于66的所有值, 'k2': 小于66的所有值}
list=[11, 22, 33, 44, 55, 66, 77, 88, 99, 90]
dic={'k1':[],'k2':[]}
for key in list:
    if key > 66:
        dic['k1'].append(key)
    elif key < 66:
        dic['k2'].append(key)
print(dic)

# 统计s='hello alex alex say hello sb sb'中每个单词的个数
# 结果如：{'hello': 2, 'alex': 2, 'say': 1, 'sb': 2}
s='hello alex alex say hello sb sb'
word_list=s.split()
dic={}
print(word_list)
for key in word_list:
    if key in dic:
        dic[key]=dic[key]+1
    else:
        dic[key]=1
print(dic) 

1.6 集合

作用：关系运算，去除重复的元素

常用方法：

in和not in

& 交集

| 并集

- 差集

^ 对称差集

>,>= ,<,<= 父集、子集

1.6.1 定义

定义：由不同元素组成的集合，集合中是一组无序排列的可hash的值，可以作为字典的key

目的：将不同的值存放在一起，不同的集合间用来做关系运算，无序纠结于集合中的单个值。

s={1,}

特点：

1. 集合内可以有多个元素，但是每个元素都必须是不可变类型，即可hash类型
2. 集合内的元素必须唯一
3. 集合内的元素是无序的

s={1,'a',1,2,3,2,2,1} # s=set({1,'a',1,2,3,2,2,1})
s1=set('hello')
print(s1,type(s1))

1.6.2 成员运算

判断一个元素是否在集合中，可以用in、not in进行判断，例如：

pythons={'jack','mary','yuanhao','tom','gangdan','biubiu'}
print('jack' in pythons)
print('frank' not in pythons) 

1.6.3 关系运算

#关系运算
s1={1,10,11,22}
s2={1,11,33}

#交集
print(s1 & s2)

#并集
print(s1 | s2)

#差集
print(s1 - s2)
print(s2 - s1)

#对称差集
print(s1 ^ s2)

#父集
s1={1,2,3,4}
s2={1,5}
print(s1 >= s2)

#子集
print(s1 <= s2)
print(s2 <= s1) 

1.6.4 练习

#集合练习一
pythons={'jack','mary','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','tom','gangdan'}
# 1. 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)
# 2. 求出所有报名的学生名字集合
print(pythons | linuxs)
# 3. 求出只报名python课程的学员名字
print(pythons - linuxs)
# 4. 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)

# 集合练习二
# 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,
# 且新列表无需保持列表原来的顺序
l=['a','b',1,'a','a']
s=set(l)
print(s)
last_list=list(s)
print(last_list)

# 2.在上题的基础上，保存列表原来的顺序
l=['a','b',1,'a','a']
new_list=[]
for item in l:
    if item not in new_list:
        new_list.append(item)
print(new_list)

new_list=[]
s=set()
for item in l:
    if item not in s:
        s.add(item)
        new_list.append(item)
print(new_list)

# 3.有如下列表，列表元素为不可hash类型，去重，得到新列表，
# 且新列表一定要保持列表原来的顺序
l=[
    {'name':'jack','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'jack','age':20,'sex':'female'},
    {'name':'jack','age':18,'sex':'male'},
    {'name':'jack','age':18,'sex':'male'},
]
l1=[]
for item in l:
    if item not in l1:
        l1.append(item)
print(l1)

ll=[]
s=set()
for item in l:
    val=(item['name'],item['age'],item['sex'])
    if val not in s:
        s.add(val)
        ll.append(item)
print(ll)

1.6.5 内置方法

#集合的内置方法
pythons={'jack','mary','frank','cat','gangdan','biubiu'}
linuxs={'cat','tom','frank'}
# 1. 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)
print(pythons.intersection(linuxs))
# 2. 求出所有报名的学生名字集合
print(pythons | linuxs)
print(pythons.union(linuxs))
# 3. 求出只报名python课程的学员名字
print(pythons - linuxs)
print(pythons.difference(linuxs))
# 4. 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)
print(pythons.symmetric_difference(linuxs))

1.6.6 add

利用集合的add方法，向集合中添加元素

s={1,2,'a','hello'}
s.add('jack')
print(s) 

1.6.7 删除

s={1,2,'a','hello','jack'}
s.pop()             # 随机删除
s.remove('jack')   # 指定元素删除，元素不存在报错
s.discard('mary')  # 指定元素删除，元素不存在不报错 

1.7 总结

按存值个数区分

标量、原子类型：数字，字符串

容器类型：      列表，元组，字典

按可变不可变区分

可变：  列表，字典

不可变：数字，字符串，元组

按访问方式区分

直接访问：               数字

按照索引访问（序列类型）：字符串，列表，元组

按照key访问（映射类型）： 字典

2. 字符编码

以下两个场景下会涉及到字符编码的问题：

1. 一个python文件中的内容是由一堆字符组成的
2. python中的数据类型字符串是由一串字符组成的

需要强调的一点是：

unicode：简单粗暴，所有字符都是2Bytes，优点是：字符à数字的转换速度快，缺点是占用空间大

utf-8：精准，对不同的字符用不同的长度表示，优点是节省空间，缺点是：字符à数字的转换速度慢，因为每次都需要计算出字符需要多长的Bytes才能准确表示

注意：

1. 内存中使用的编码是unicode，用的是空间换时间(程序都需要加载到内存才能运行，因而内存应该是尽可能的保证快)
2. 硬盘中或者网络传输用utf-8，网络I/O延迟或磁盘I/O延迟要远大于uft-8的转换延迟，因而I/O应该是尽可能的节省带宽，保证数据传输的稳定性。

字符编码的转换流程：

总结：

无论用何种编辑器，要防止文件出现乱码（请一定要注意：存放一段代码的文件也仅仅是一个普通文件而已，此处指的是文件没有执行前，我们打开文件时出现的字符），核心法则：文件以什么编码保存，就以什么编码方式打开。

3.文件操作

文件的复杂操作,其实就两种操作:读和写,其他操作在Python的开发中都不用太关注,主要是因为操作系统已经帮我们做其他方面的工作。

文件操作步骤：

1. 打开文件
2. 对文件进行操作
3. 关闭文件

3.1 文件读

读模式不能进行写操作，只能进行读操作

f = open('a.txt','r',encoding='utf-8')   # 应用程序向操作系统发起的请求，指定utf-8编码、以只读的方式打开文件
res = f.read()    # read方法，是文件头读到文件尾部
print(res)        # 打印文件读取结果

f.readline()      # 一次读取一行
f.readlines()     # 读取所有行

f.close()         # 关闭文件操作 关闭的是操作系统的文件句柄，变量f还存在，已经不能对文件进行操作

with open('a.txt','r',encoding='utf-8') as f: # 此种方法对文件操作完成后，会自动调用f.close(),关闭文件操作句柄
    pass

3.2 文件写

写模式，只能对文件进行写操作，不能进行读

f = open('a.txt','w',encoding='utf-8') # 应用程序向操作系统发起的请求，指定utf-8编码、以只写的模式打开文件
f.write('111\n')                   # 单个值的写
f.write('222\n')
f.writelines(['a\n','b\n','c\n']) # 列表的写
f.close()

3.3 文件修改操作

文件修改操作，类似于vim的编辑，先把修改文件保存到临时文件夹中，让后删除原来文件，最后把临时文件重新命名为源文件。例如：

import os
# 文件修改
with open('old.txt','r',encoding='utf-8') as read_f,\
    open('.old.txt.swap','w',encoding='utf-8') as write_f:
    for line in read_f:
        if 'jack' in line:
            line = line.replace('jack','mary')
        write_f.write(line)
os.remove('old.txt')
os.rename('.old.txt.swap','old.txt')