Python学习 3day__基础知识

元组的函数

　　基本和list通用

a = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(len(a))       # 获取元组长度
print(max(a))       # 获取元组最大值
print(min(a))       # 获取元组最小值
l = [1, 5, 9]
t = tuple(l)        # 将其他类型转换为tuple

元组变量交换法

a = 1
b = 2
a, b =b, a
print(a)
print(b)

集合 set

　　一堆确定的无序的唯一数据，每一个数据成为一个元素

a = set()              # 定义一个空集合
print(type(a))
print(a)
a = {1, 2, 3, 4}        # 定义一个集合，这种方法必须有元素否则是一个dict类型
print(type(a))
print(a)

集合的特征

　　数据无序，因此无法使用索引和切片
　　内部元素具有唯一性，无重复数据

集合序列操作

s = {9, 'I', 'Love', 'Python'}
print(s)
print('I' in s)

集合遍历操作
　　for循环

s = {9, 'I', 'Love', 'Python'}
for i in s:
    print(i, end=" ")

　　带有元组的集合遍历

s = {(9, 6, 8), ('I', 'Love', 'Python')}

for k, m, n in s:
    print(k, "---", m, "---", n)
for p in s:
    print(p)

集合函数

　　intersection:交集
　　difference:差集
　　union:并集
　　issubset：检查一个集合是否是另一个子集
　　issuperset：检查一个集合是否为另一个超集

s1 = {1, 2, 3, 4, 5}
s2 = {5, 6, 7, 8, 9}
s_1 = s1.intersection(s2)
print(s1)
s_2 = s1.difference(s2)
print(s_2)
s_3 = s1.issubset(s2)
print(s_3)

　　冰冻集合 frozen set

　　　　　不能修改的集合就叫做冰冻集合，是一种特殊集合

# 创建frozenset
s = frozenset()
print(type(s))
print(s)

dict字典

　　字典是一种组合数据，没有顺序的组合数据，数据以键值对的形式出现

# 创建空字典
d = {}
print(type(d))
d = dict()
print(type(d))
# 创建有值的字典
d = {"first": 1, "second": 2, "third": 3}
print(type(d))
print(d)
# 利用关键字创建字典
d = dict(first=1, second=2, third=3)

　　字典的特征

　　　　字典是序列类型，但是是无序序列，所以没办法分片和索引
　　　　key：必须是可哈希的值
　　　　value:可以是任何值


　　字典的常用操作

# 访问
d = {"first": 1, "second": 2, "third": 3}
print(d["first"])
print(d["second"])   #注意中括号内是键值
d["first"] = 'one'
print(d["first"])
# 删除
del d["first"]
print(d)
# 成员检测 in not in
# 成员检测检测的是key的内容
d = {"first": 1, "second": 2, "third": 3}

if 2 in d:
    print("666")
if "first" in d:
    print("999")

# 按key来使用for循环
d = {"first": 1, "second": 2, "third": 3}
for k in d:
    print(k, d[k])

# 和上面的代码是一个操作
for k in d.keys():
    print(k, d[k])

# 只访问字典的值
for v in d.values():
    print(v)
# 特殊用法
for k, v in d.items():
    print(k, '---', v)

　　字典生成式

d = {"first": 1, "second": 2, "third": 3}
# 常规生成式
dd = {k:v for k,v in d.items()}
print(dd)
# 带条件表达式的生成式
dd = {k:v for k,v in d.items() if v % 2 ==0}
print(dd)

　　字典相关函数

# 通用函数： len,max,min,dict
#str(字典):返回字典的字符串格式
d = {"first": 1, "second": 2, "third": 3}
print(str(d))

# clear:清空字典
d.clear()
print(d)
# iteams(): 返回字典的键值对组成的元组格式
d = {"first": 1, "second": 2, "third": 3}
i = d.items()
print(type(i))
print(i)
# keys：返回字典的键组成的结构
k = d.keys()
print(type(k))
print(k)
# values: 一个可迭代的结构
v = d.values()
print(type(v))
print(v)
# get:根据制定键的返回相应的值，好处是可以设置默认值
d = {"first": 1, "second": 2, "third": 3}
print(d.get("aaaaa"))
print(d.get("first",80))
print(d.get("aaaa", 8888))

#formkeys:使用指定的序列作为键，使用一个值作为字典的所有的键的值

a = ["one", "two", "three"]
d = dict.fromkeys(a, "niubi")  # 这里要注意传递的参数类型
print(d)

面向对象编程-OOP
　　思想：接触到任意一个任务，首先想到的是任务这个世界的构成，是由模型组成的
   　　 继承
   　　 封装
   　　 多态

　　类和对象的概念

　　抽象名词，代表一个大集合，共性的事物
　　对象：具象的事物，单个个体
　　
　　类的基本实现
　　　　类的命名
        　　遵守变量命名规范
        　　避开和系统命名相似的命名
    　　类的声明
        　　必须用class关键字
       　　 类由属性和方法构成，其他不允许出现
    　　类的实例化
        　　变量 = 类命()
    　　访问对象成员
        　　obj.成员属性名称
        　　obj.成员方法
    　　可以通过内置变量检测类和对象的所有成员
        　　对象所有成员检查
            　　obj.__dict__
       　　 类所有的成员
        　　class_name.__dict__    

定义一个学生类

class Student():        # 类
    pass

xiaowang = Student()     # 对象

定义一个学PY的学生的类

class PyStdent():
    name = None
    age = 16
    course = "Python"

    def doHomework(self):
        print("俺在做作业")
        return None

# 实例化一个学生
xiaozhang = PyStdent()
print(xiaozhang.name)
print(xiaozhang.age)
xiaozhang.doHomework()