Python学习-基础篇2-变量总结

类型概括：

数据类型

　　数字（整形，长整形，浮点型，复数）

　　字符串

　　字节串：在介绍字符编码时介绍字节bytes类型

　　列表

　　元组

　　字典

　　集合

各类型的详细解说：

一、数字

整型与浮点型

#整型int
　　作用：年纪，等级，身份证号，qq号等整型数字相关
　　定义：
　　　　age=10 #本质age=int(10)

#浮点型float
　　作用：薪资，身高，体重，体质参数等浮点数相关

    salary=3000.3 #本质salary=float(3000.3)

#二进制，十进制，八进制，十六进制 

#长整形（了解）
    在python2中（python3中没有长整形的概念）：　　　　　　
    >>> num=2L
    >>> type(num)
    <type 'long'>

#复数（了解）　　
    >>> x=1-2j
    >>> x.real
    1.0
    >>> x.imag
    -2.0　　

该类型总结：

# 1 存一个值or存多个值
#     只能存一个值

# 3 可变or不可变
#     ！！！不可变

二、字符串

#作用：名字，性别，国籍，地址等描述信息

#定义：在单引号双引号三引号内，由一串字符组成
name='zhenxi'

#（1）常用的操作：
#1、按索引取值(正向取+反向取) ：只能取
正向代码：

name='zhenxi'
print(name[0])
反向代码：

name='zhenxi'
print(name[-1])

#2、切片(顾头不顾尾，步长)
正向切片代码：

name='zhenxi'
print(name[0:4])--默认步长为1
反向切片代码：

name='zhenxi'
print(name[-4:])
颠倒顺序代码：

name='zhenxi'
print(name[::-1])

#3、长度len
长度代码：

name='zhenxi'
print(len(name))

#4、成员运算in和not in
in代码：

name='zhenxi'
print('z' in name)
TRUE
not in代码：

name='zhenxi'
print('z' not in name)
FLASE

#5、移除空白strip 
strip代码：

name='           zhenxi       '
print(name)
print(name.strip())

#6、切分split 

name='/home/view/a/b/c/123.txt'
print(name)
print(name.split('/'))

#7、循环

name='zhenxi'
for i in name:
    print(i)


#（2）常用操作升级：

#1、strip,lstrip,rstrip（去除空格，去除字符串左边的空格，去除字符串右边的空格）
格式：变量名.strip('需要匹配的需要去除的字符，默认是空格')

#strip
name='*zhenxi**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))

#2、lower,upper （全小写，全大写）（把变量里面的字符串都换成小写，把变量里面的字符串都换成大写）

name='zhenxi'
print(name.lower())
print(name.upper())

#3、startswith,endswith （以什么开头，以什么结尾）
格式：变量.endswith('需要匹配的字符串')，startswith同理。

name='zhenxi_NB'
print(name.endswith('NB'))
print(name.startswith('zhenxi'))

#4、format的三种玩法 （占位符的另一种表达方式，相对于占位符，format更加灵活多变）
格式：{}.format（需要写入{}的值）

res='{} {} {}'.format('zhenxi',18,'male')
print(res)
res='{1} {0} {1}'.format('zhenxi',18,'male')
print(res)
res='{name} {age} {sex}'.format(sex='male',name='zhenxi',age=18)
print(res)

#5、split,rsplit （切分，有切分）
格式:变量名.split('需要匹配的分隔符。默认是空格')

name='root:x:0:0::/root:/bin/bash'
print(name.split(':'))
name='C:/a/b/c/d.txt'
print(name.split('/',1))
name='C:/a/b/c/d.txt'
print(name.rsplit('/',1))

#6、join（插入）
格式：变量名.join(['需要加入的值']) 

tag=' '
print(tag.join(['zhenxi','say','good','morning'])) #可迭代对象必须都是字符串

#7、replace （替换）
格式:变量名.replace('原字符串','新字符串',替换次数)

name='zhenxi say :i have  pen,i have zhenxi'
print(name.replace('zhenxi','zx',1))

#8、#isdigit：可以判断bytes和unicode类型,是最常用的用于于判断字符是否为"数字"的方法

age=input('>>: ')
print(age.isdigit())

#（3）不常用操作：

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

#center,ljust,rjust,zfill
name='zhenxi'
print(name.center(30,'-'))
print(name.ljust(30,'*'))
print(name.rjust(30,'*'))
print(name.zfill(50)) #用0填充

#expandtabs（tab的宽度）
name='zhenxi	hello'
print(name)
print(name.expandtabs(1))

#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='egon say hi'
print(msg.title()) #每个单词的首字母大写

#is数字系列
#在python3中
num1=b'4' #bytes
num2=u'4' #unicode,python3中无需加u就是unicode
num3='四' #中文数字
num4='Ⅳ' #罗马数字

#isdigt:bytes,unicode
print(num1.isdigit()) #True
print(num2.isdigit()) #True
print(num3.isdigit()) #False
print(num4.isdigit()) #False

#isdecimal:uncicode
#bytes类型无isdecimal方法
print(num2.isdecimal()) #True
print(num3.isdecimal()) #False
print(num4.isdecimal()) #False

#isnumberic:unicode,中文数字,罗马数字
#bytes类型无isnumberic方法
print(num2.isnumeric()) #True
print(num3.isnumeric()) #True
print(num4.isnumeric()) #True

#三者不能判断浮点数
num5='4.3'
print(num5.isdigit())
print(num5.isdecimal())
print(num5.isnumeric())
'''
总结:
    最常用的是isdigit,可以判断bytes和unicode类型,这也是最常见的数字应用场景
    如果要判断中文数字或罗马数字,则需要用到isnumeric
'''

#is其他
print('===>')
name='zhenxi123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成

print(name.isidentifier())
print(name.islower())
print(name.isupper())
print(name.isspace())
print(name.istitle())

该类型总结
# 1 存一个值or存多个值
#     只能存一个值

# 2 有序

# 3 可变or不可变
#     ！！！不可变：值变，id就变。不可变==可hash

三、列表

#作用：多个装备，多个爱好，多门课程，多个女朋友等

#定义：[]内可以有多个任意类型的值，逗号分隔
my_girl_friends=['allen','harei','peisi',4,5] #本质my_girl_friends=list([...])
或
l=list('abc')

#常用的操作：
#1、按索引存取值(正向存取+反向存取)：即可存也可以取   
正向存取代码：

l=[1,2,3,4,5,6]
print(id(l))
print(l[0])
l[1]=7
print(l,id(l))
反向存取代码:

l=[1,2,3,4,5,6]
print(id(l))
print(l[-1])
l[-3]=7
print(l,id(l))

#2、切片(顾头不顾尾，步长) 
正向切片（默认步长为1，格式和字符串相同）：

l=[1,2,3,4,5,6]
print(l[0:3])
print(l[0:5:2])

反向切片：

l=[1,2,3,4,5,6]
print(l[-5::2])
颠倒顺序：
print(l[::-1])

#3、len()长度 
代码演示：

l=[1,2,3,4,5,6]
print(len(l))

#4、成员运算in和not in 

l=[1,2,3,4,5,6]
in代码：
print(1 in l)
not in代码：
print(7 not in l)

#5、append()追加 

l=[1,2,3,4,5,6]
l.append(8)
print(l)

#6、删除 
del单纯的删除：

l=[1,2,3,4,5,6]
del l[3]
print(l)
remove()方法删除：

l=[1,2,3,4,5,6]
n=l.remove(5)
print(l)
pop()删除并取出一个值：

l=[1,2,3,4,5,6]
n=l.pop(2)
print(l)
print(n)

#7、循环

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

#常用升级操作：
#8、insert()插入数据：
格式：变量名.insert（索引,值）
示例代码：

l=[1,2,3,4,5,6]
l.insert(1,8)
print(l)
#9、count()统计列表中的元素出现的次数：
格式：变量名.count（值）
示例代码：

l=[1,2,3,4,5,6,1,8,2,3,4,1,1]
print(l.count(1))

#10、clear()清除列表中的数据：
格式：变量名.clear（）
示例代码：

l=[1,2,3,4,5,6]
print(l)
l.clear()
print(l)

#11、copy()复制列表：
格式：变量名.copy()
示例代码：

l=[1,2,3,4,5,6]
n=l.copy()
print(n)

#12、extend()批量插入值：
格式：变量名.extend(变量或者字符串)
示例代码：

l=[1,2,3,4,5,6]
n=['a','b']
l.extend(n)
print(l)
l.extend('c')
print(l)
c={'q':1,'w':2}
l.extend(c)
print(l)
d={'e':'zhen','r':'xi'}
l.extend(d)
print(l)
p=('aa',123,'bb',456)
l.extend(p)
print(l)

通过以上的示例代码可以得出字典旳话只能插入key而非key-value！！

#13、index（）查看列表中的值所在的位置：
格式：变量名.index(值)
示例代码：

l=[1,2,3,4,5,6,]
print(l.index(4))

#14、reverse() 函数用于反向列表中元素。
格式：变量名.reverse()
示例代码：

l=[3,6,5,7,1,2,'x','a','t']
l.reverse()
print(l)

#15、sort（）排序
格式：变量名.sort()
示例代码：
升序：

l=['3','6','5','7','1','2','x','a','t']
l.sort()
print(l)
降序：
l=['3','6','5','7','1','2','x','a','t']
l.sort(reverse=True)
print(l)

该类型总结

# 1 存一个值or存多个值
#     可以存多个值，值都可以是任意类型

# 2 有序

# 3 可变or不可变
#     ！！！可变：值变，id不变。可变==不可hash

四、元祖

#作用：存多个值，对比列表来说，元组不可变（是可以当做字典的key的），主要是用来读

#定义：与列表类型比，只不过[]换成()
age=(11,22,33,44,55)本质age=tuple((11,22,33,44,55))

常用操作：

#1、按索引取值(正向取+反向取)：只能取 
正向取代码：

age=(11,22,33,44,55,66)
print(age[2])

反向取代码：  

age=(11,22,33,44,55,66)
print(age[-2])

#2、切片(顾头不顾尾，步长
正向切片：

age=(11,22,33,44,55,66)
print(age[1:3])
print(age[1:5:2])
反向切片：

age=(11,22,33,44,55,66)
print(age[-4:])

#3、len()长度 
示例代码：

age=(11,22,33,44,55,66)
print(len(age))

#4、成员运算in和not in 

age=(11,22,33,44,55,66)
print(11 in age)
age=(11,22,33,44,55,66)
print(77 not in age)

#5、循环

age=(11,22,33,44,55,66)
for i in age:
    print(i)

 #常用升级操作：

统计元祖中的元素出现的次数：

age=(11,22,33,44,55,66,11,22)
print(age.count(11))

查看某个元素在元祖里面的位置：

age=(11,22,33,44,55,66,)
print(age.index(55))


五、字典

#作用：存多个值,key-value存取，取值速度快

#定义：key必须是不可变类型，value可以是任意类型
info={'name':'zhenxi','age':18,'sex':'male'} #本质info=dict({....})
或
info=dict(name='zhenxi',age=18,sex='male')
或
info=dict([['name','zhenxi'],('age',18)])
或
{}.fromkeys(('name','age','sex'),None)

 常用操作：

#1、按key存取值：可存可取：
示例代码：

info={'name':'zhenxi','age':18,'sex':'male'}
print(info['name'])
info['name']='Zx'
print(info['name'])

#2、len()长度len
示例代码： 

info={'name':'zhenxi','age':18,'sex':'male'}
print(len(info))

#3、成员运算in和not in （这里in的是key而不是值）
示例代码：

info={'name':'zhenxi','age':18,'sex':'male'}
print('name' in info)
print('hobby' not in info)

#4、删除 
#pop()删除：
格式：变量名.pop(key)

info={'name':'zhenxi','age':18,'sex':'male'}
print(info.pop('name'))
print(info)
#popitem（）删除：
格式：变量名.popitem()(默认是删除字典中末尾的，并且是把删除结果以元祖的形式展示的)

info={'name':'zhenxi','age':18,'sex':'male'}
print(info.popitem())

#5、键keys()，值values()，键值对items() 
显示字典中的key：

info={'name':'zhenxi','age':18,'sex':'male'}
#显示字典中的key：
print(info.keys())
#用列表的形式显示字典中的key：
print(list(info.keys()))
#用列表的形式显示字典中的key的第一个值：

print(list(info.keys())[0])

#用列表显示字典中的值：

info={'name':'zhenxi','age':18,'sex':'male'}
print(list(info.values()))

#用列表显示字典里面的项目：

info={'name':'zhenxi','age':18,'sex':'male'}
print(list(info.items()))

#6、循环（字典在循环的时候变量i对应的值是字典中的key）

info={'name':'zhenxi','age':18,'sex':'male'}
for i in info:
    print(i,info[i])

#常用操作升级：
#.get()获取值：
格式：变量名.get(key,如果key对应的值为空则设定的返回值)
示例代码：

info={'name':'zhenxi','age':18,'sex':'male'}
#print(info['hobbies'])（报错！）
print(info.get('name'))
print(info.get('hobbies','none'))

l=info.pop('name1',None)
print(l)

#.update()更新字典：这个语法可以把两个字典整合之后再赋予被更新的字典，原字典里面有的不会被更新，原字典没有的就添加进来；
格式：变量名.update(其他变量名)
示例代码：

info={'name':'zhenxi','age':18,'sex':'male'}
d={'x':1,'y':2,'name':'ZX'}
info.update(d)
print(info)

#.setdefault()添加或修改字典：该语法用于设置某个key值，如果该key存在，则不修改，如果没有就添加上key和默认值或者设定值；
格式：变量名.setdefault（key,value）
示例代码：

info={'name':'egon','sex':'male'}
value=info.setdefault('age')
print(value)
print(info)
info={'name':'egon','sex':'male'}
value=info.setdefault('age',18)
print(value)
print(info)

#.append()添加值：
格式:字典['key'].append(value)
示例代码：

info={'name':'zhenxi',}
info['hobbies']=[]
info['hobbies'].append('music')
info['hobbies'].append('read')
print(info)

小练习：
判定该字典是否有'hobbies'这个key如果没有就加上该key，如果有就添加'music'值：
没有key：

info={'name': 'egon'}
if 'hobbies' not in info:
    info['hobbies']=[]
else:
    info['hobbies'].append('music')
print(info)

有key：

info={'name': 'egon', 'hobbies': []}
if 'hobbies' not in info:
    info['hobbies']=[]
else:
    info['hobbies'].append('music')
print(info)

小实验：

info={'name':'egon',}
hobbies_list=info.setdefault('hobbies',[])
n=info.setdefault('sex',[])
print(hobbies_list)
print(n)
n.append('play')
n.append('read')
print(info)

【info={'name':'egon',}
hobbies_list=info.setdefault('hobbies',[])
n=info.setdefault('sex','male')
print(hobbies_list)
print(n)
n.append('play')
n.append('read')
print(info)】报错！！

实时证明：.append默认只会把值添加到末尾的，如果末尾的值不匹配就会报错！！

#二：该类型总结
# 1 存一个值or存多个值
#     可以存多个值，值都可以是任意类型,key必须是不可变类型
#
# 2 无序

# 3 可变or不可变
#     ！！！可变：值变，id不变。可变==不可hash

六、集合

#作用：关系运算，去重
#定义集合：{}内用逗号分割每个元素都必须是不可变类型,元素不能重复,无序
# s={1,'a',[1,2]} #TypeError: unhashable type: 'list'
# s={1,2,3,1} #s=set({1,2,3,1})
# print(s,type(s))

常用操作：
#1、.len()长度：
格式：和其他的一致；
示例代码：

s={1,2,3}
print(len(s))

#2、成员运算in和not in
示例代码：

s={1,2,3,'a','b','c'}
print(2 in s)
print('a' in s)
print('d' in s)
print('d' not in s)
print(1 not in s)

#3、合集 |（A.union(B)）

Small={1,2,3}
Big={'a',1,'b',4,'c'}
print(Small | Big)

#4、交集 & ：两个集合同时拥有的值

Small={1,2,3}
Big={'a',1,'b',4,'c'}
print(Small & Big)

#5、对称差集^(A.symmetric_difference(B)):没有共同拥有的集合；

Small={1,2,3}
Big={'a',1,'b',4,'c'}
print(Small ^ Big)

#6、差集 - （A.difference(B)）：只有A集合拥有的值；

Small={1,2,3}
Big={'a',1,'b',4,'c'}
print(Small - Big)

#7、父集:>,>=,子集：<，<=

s1={1,2,3}
s2={1,2,}
print(s1 >= s2)
print(s1.issuperset(s2))
print(s2.issubset(s1))

#8、循环：

s={'a','b','c',1,2,3,4,5,6}
for i in s:
    print(i)

#常用操作升级：

#差集的三种表达方式：

s1={1,2,3}
s2={1,2,}
print(s1-s2)
print(s1.difference(s2))
s1.difference_update(s2) #s1=s1.difference(s2)
print(s1)

#.pop()随机取集合值：
s2={1,2,3,4,5,'a'}
print(s2.pop())

#.add（）为集合添加值：
s2.add('b')
print(s2)

#.discard()发现集合里面的值，没有则默认返回；.remove()删除集合里面的值，如果没有就报错！！

s2={1,2,3,4,5,'a'}
print(s2.discard('b'))
s2.remove('b') #删除的元素不存在则报错
print(s2)

#、查看两个集合是否有交集，如果没有就返回True：
s1={1,2,3,4,5,'a'}
s2={'b','c',}
print(s1.isdisjoint(s2)) #两个集合没有共同部分时，返回值为True


#、.update()批量添加值
s2={1,2,3,4,5,'a'}
s2.update({6,7,8})
print(s2)

#用集合去重：
l=['a','b',1,'a','a']
print(list(set(l)))

print(set('hello'))
集合可以把字典变成集合，去除key：
print(set({'a':1,'b':2,'c':3}))

七、字符编码
总结：

1、存取文件不乱码的法则：用什么编码存的，就要用什么编码读
2、
    unicode-----encode----->gbk
    gbk-------->decode----->unicode

3、
    python3解释器默认使用的字符编码是utf-8
    python2解释器默认使用的字符编码是ascii
4
    python2的str就是python3的bytes
    python2的unicode就是python3的str

八、文件处理
处理流程：

#1. 打开文件，得到文件句柄并赋值给一个变量
#2. 通过句柄对文件进行操作
#3. 关闭文件

大概操作参数介绍：

#1. 打开文件的模式有(默认为文本模式)：
r ，只读模式【默认模式，文件必须存在，不存在则抛出异常】
w，只写模式【不可读；不存在则创建；存在则清空内容】
a， 之追加写模式【不可读；不存在则创建；存在则只追加内容】

#2. 对于非文本文件，我们只能使用b模式，"b"表示以字节的方式操作（而所有文件也都是以字节的形式存储的，使用这种模式无需考虑文本文件的字符编码、图片文件的jgp格式、视频文件的avi格式）
rb 
wb
ab
注：以b方式打开时，读取到的内容是字节类型，写入时也需要提供字节类型，不能指定编码

#3. 了解部分
"+" 表示可以同时读写某个文件
r+， 读写【可读，可写】
w+，写读【可读，可写】
a+， 写读【可读，可写】


x， 只写模式【不可读；不存在则创建，存在则报错】
x+ ，写读【可读，可写】
xb

操作文件方法：

#掌握
f.read() #读取所有内容,光标移动到文件末尾
f.readline() #读取一行内容,光标移动到第二行首部
f.readlines() #读取每一行内容,存放于列表中

f.write('1111
222
') #针对文本模式的写,需要自己写换行符
f.write('1111
222
'.encode('utf-8')) #针对b模式的写,需要自己写换行符
f.writelines(['333
','444
']) #文件模式
f.writelines([bytes('333
',encoding='utf-8'),'444
'.encode('utf-8')]) #b模式

#了解
f.readable() #文件是否可读
f.writable() #文件是否可读
f.closed #文件是否关闭
f.encoding #如果文件打开模式为b,则没有该属性
f.flush() #立刻将文件内容从内存刷到硬盘
f.name

基本操作演示-打开文件：

#1、打开已有的文件（相对路径）并读取数据（重要提醒：一定要在结尾加上f.close()把文件关闭，否则会有堆积垃圾的可怕后果，系统会渐渐变卡）：

f=open('a.txt','r',encoding='utf-8')
data=f.read()
print(data)
print(f)
f.close()

#2、打开文件的绝对路径：

f=open(r'C:UserszxPycharmProjectsPython20Day2a.txt',encoding='utf-8')
data=f.read()
print(data)
print(f)
f.close()

###另一种开文件的方式（不需要在整体结尾加上f.close()）:

with open('a.txt','r',encoding='utf-8') as f: #f=open('a.txt','r',encoding='utf-8')

data=f.read()
print(data)
print(f)

练习，利用b模式，编写一个cp工具，要求如下：

　　1. 既可以拷贝文本又可以拷贝视频，图片等文件

　　2. 用户一旦参数错误，打印命令的正确使用方法，如usage: cp source_file target_file

　　提示：可以用import sys，然后用sys.argv获取脚本后面跟的参数

　　示例代码：　

import sys
if len(sys.argv) != 3:
    print('usage: cp source_file target_file')
    sys.exit()

source_file,target_file=sys.argv[1],sys.argv[2]
with open(source_file,'rb') as read_f,open(target_file,'wb') as write_f:
    for line in read_f:
        write_f.write(line)

　基本操作演示-文件内操作：

一: read(3)：

　　1. 文件打开方式为文本模式时，代表读取3个字符

　　2. 文件打开方式为b模式时，代表读取3个字节

二: 其余的文件内光标移动都是以字节为单位如seek，tell，truncate

注意：

　　1. seek有三种移动方式0，1，2，其中1和2必须在b模式下进行，但无论哪种模式，都是以bytes为单位移动的

　　2. truncate是截断文件，所以文件的打开方式必须可写，但是不能用w或w+等方式打开，因为那样直接清空文件了，所以truncate要在r+或a或a+等模式下测试效果

示例代码（用seek函数编写一个动态追踪文件内容的功能）：

import time
with open('test.txt','rb') as f:
    f.seek(0,2)
    while True:
        line=f.readline()
        if line:
            print(line.decode('utf-8'))
        else:
            time.sleep(0.2)
文件修改演示：
方式一：将硬盘存放的该文件的内容全部加载到内存，在内存中是可以修改的，修改完毕后，再由内存覆盖到硬盘（word，vim，nodpad++等编辑器）
演示代码：

import os

with open('a.txt') as read_f,open('.a.txt.swap','w') as write_f:
    data=read_f.read() #全部读入内存,如果文件很大,会很卡
    data=data.replace('zhen','NB') #在内存中完成修改

    write_f.write(data) #一次性写入新文件

os.remove('a.txt')
os.rename('.a.txt.swap','a.txt') 
方式二：将硬盘存放的该文件的内容一行一行地读入内存，修改完毕就写入新文件，最后用新文件覆盖源文件

import os

with open('a.txt') as read_f,open('.a.txt.swap','w') as write_f:
    for line in read_f:
        line=line.replace('zhenxi','NB')
        write_f.write(line)

os.remove('a.txt')
os.rename('.a.txt.swap','a.txt')