Python基础（三）

总结

列表和字典是最常用的

0、课前

man ls --man 查看方法 ，前后翻阅就是f，b，退出就是q

--help -查看方法

Liunx下三剑客

ls | grep GH.py

​ grep --配合 | 使用 ，用来查找

​ | --管道，把两个命令加在一起，把前面的结果给后面的 命令

一、散列类型（无序）

3.6版本后是有序的，但是先不讨论,但是是可变的

【1】集合

#1.唯一性（不能有相同元素）
#2.无序性，不可以通过索引查找
#3.可变性
#*.一般用集合去掉重复的元素（去重）
​
#定义集合
b = {1,2,3}  #set 定义第一种方法
set({1,2,3,'Hello','Python'})    #set 定义第二种方法
#注*定义一个空的{}，不是集合，是一个dict字典
​
#集合的三种运算
#交集 & 两个集合中共有的元素
a = {1,2,3,4,5,6}
b = {2,3,4}
v = a&b   #{2,3,4}
​
#并集 | 两个集合合在一起，相同的元素合为一个
a = {1,2,3,4,5,6}
b = {2,3,4}
v = a|b    #{1,2,3,4,5,6}
​
#差集 - 减去两个集合相同的部分，然后保留剩下的元素（要多的减少的）,单单带数字是不能少减多的
a = {1,2,3,4,5,6}
b = {2,3,41}
v = a-b   #{1,5,6}
​
a = {1,2,3,'Python','Hello'}
b = {'Python','hello'}
v = b-a     #{'hello'}

#增
#add('')  无序的，插进去的元素的位置是不定的
a = {1,2,3,'Hello','Python!'}
a.add('Navtion')    #{1, 2, 3, 'Navtion', 'Python!', 'Hello'}
#update([])  里面是放可迭代对象的（多个元素的）,可以存放 list,tuple,str,等等
a = {1,2,3}
a.update({'Python'})
a.update(['Hello'])
a = {1, 2, 3, 'Python', 'Hello'}
#删
#pop()  #随机删除一个元素
a = {1, 2, 3, 'Python', 'Hello'}
a.pop()   #1
#remove() #指定删除一个元素
a = {1,2,3,'Python','Hello'}
a.remove('Python')  #{1,2,3,'Hello'}
#改
#update()
a.update('Fyn')
#由于集合是个无序系列，不能索引取值，固就不能修改
​
#查
#isdisjoint('')  判断没有交集，没有返回True，有返回False
a = {1,2,3,'Python','Hello'}
b = {2,3}
c = {4,5}
a.isdisjoint(b) #False  ,有交集
a.isdisjoint(c) #True  ,没有交集
​
#issubset('')  判断是否包含于，是后面的括号里的包含括号外的，如果包含返回True
a = {1,2,3,'Hello','Python'}
b = {1,2,3}
b.issubset(a)  #True  b是a的子集
#issuperset()  #判断是否被包含，跟issubset相反
a = {1,2,3,'Hello','Python'}
b = {1,2,3}
b.issuperset(a)  #False  a不是b的子集

update:

【2】字典 dict 在字典里'键'是唯一的，，但是'key'是不可变的，可变对象不可以当key值

特点：

​ 1、无序性

​ 2、可变性，但是键是唯一不可变的

优点：方便、准确

#{key:value}   --键值对  ，
#字典的定义
a = {'name':'Fyn','age':18} #第一种定义
b = dict(name='gh',age=23)  #第二种定义
#通过key取值
a = {'name':'Fyn','age':18}
b = a['name'] #'Fyn'

字典第二种定义方法：

#修改 ，通过获取key来修改key的值
a = {'name':'FGH','age':20}
b = a['name']  #'FGH'
a.update({'name':'老王'})  #改成老王，里面填写迭代对象 {'name': '老王', 'age': 20}
​
#增加
a = {'name':'Fyn','age':18}
a['gh'] = ''  #如果没有这个key，就新的一个key
b = a.copy
a.update({'love':'giuta'})  #有则修改，无则增加
a.setdefault('name',888)  #有则查，无则增,不加value就是查询的作用
b = a.fromkeys('name',18)   #返回一个新的字典
#删除
#pop(key)  #输入键
a = {'name':'Fyn','age':18}
a.pop('name')  #'Fyn'
#popitem()  #随机删除一个键值对
a = {'name':'Fyn','age':18} 
a.popitem()  #('age', 18) 返回的是tuple类型
#clear()   #清空后是dict
a = {'name':'Fyn','age':18} 
a.clear()  #{}
​
#查
#get(key)  #获取key对应的值，没有找到会返回none，不会报错
a = {'name':'Fyn','age':19}
a.get('name')  #'Fyn'
​
#keys()   #获取字典里所有的键  ,返回的是dict_values类型
a = {'name':'Fyn','age':19}
a.keys()  #dict_keys(['name','age'])
​
#values()  #获取字典里的所有值 ,返回的是dict_values类型
a = {'name':'Fyn','age':19}
a.values()  #dict_values(['Fyn',19])
​
#items()  #获取所有的键值对，字典是不可以循环取值的
a = {'name':'Fyn','age':19}
a.items()  #dict_items([('name','Fyn'),('age',19)])
​

fromkeys()

三、运算符优先级

is --判断的是内存地址是否相等 （身份运算符 ）

is not --跟is相反 （身份运算符 ）

1 in a --判断1是否在a里面，是的返回True （成员运算符 ）

1 not in a --判断1是否在a里面，不是的返回True （成员运算符 ）

 

四、逻辑运算符

#1、查看对象类型
#type
isinstance(a,int)  #--判断一个数是什么类型的，对返回True
​
#2、比较运算符
#==  --判断是否相等
a = 12
b = 12
c = 13
a == b  #True
a == c #False
#!=   --不等于,跟==相反  ，不等于返回True
a = 12
b = 12
c = 13
a != b  #False
a != c  #True
​
#3、判断多个条件
#and 与  有一个不满足返回False
a = 12
b = 12
c = 13
d = 12
a==b and a==c  #False
a==b and a==d  #True
​
#or 或  连接多个条件，只要有一个满足则返回True
a = 12
b = 12
c = 13
a==b or a==c  #True
​
#not 非
a = 12
b = 12
c = 13
not a==b  #False
not a==c  #True
​