python学下day3

之前内容的补充：

print()：输出东西的时候，尽量不要输岀列表；

因为输岀列表的时候是自动调用其中的一个__str__的方法;它返回什么就显示什么；这样很不安全。

interable：意思是可迭代的 --> 可以被for循环进行循环的。

int类型补充

创建：

n = 123  或  n = int(123)

注意：

1、上面两个创建的反方式结果都是一样的，但是在python里面；它们本质上还是不一样的。

2、整型的装还闯入参数必须全是数字；不然会报错！

3、n = 123 在运行的时候都的经过 int() 的转化；--> 这个转化过程是调用了int类邻面的 __init__ (初始化)方法

总结：

int(), str(), list(), tuple(), dict()等，只要是一个类型后面加个括号；这代码执行的时候；它会自动去找对应类里面的 __init__

意思：每个类里面都有这个 __init__方法

分析：int里面的类的 __init__方法

• x：表示我们传入的整型参数
• base=10：表示整型参数的进制

int()：里面传2个参数的；第一个参数是进制代码；则第二个参数是你想结果按什么进制的类型显示；运行时会按这个进制进行显示

n = int("100", 2)
print(n)    #结果是 4
n = int("100", 4)
print(n)    #结果是 16

我们创建变量；同时也会在内存创建出对应变量值的地址

python的优化机制：

n1 = 123
n2 = 123
# 正常道理说上面的代码在内存中会对应2个地址；但是python觉得这样很浪费内存
# 所以设定了 -5 ~ 257之间的数即使像上面这样写；也会根据值将其地址合并；并让其公用一个地址
# 测试内存地址：id(n1)  id(n2):结果显示是一样的

# 超出这个范围
n3 = 1234
n4 = 1234
# 同样用 id(n3) id(n4) 去测试结果显示是不一样的

总结：我们可以通过 id(变量名)：查看变量名对应值的内存地址

int 类型的长度

长度会根据电脑的不同范围也不同；如果设置超出了范围；则会报错 

32位系统：-2**31 ~ 2**31-1

64位系统：-2**63 ~ 2**63-1

在 python3.0后已经没有长度限制了；只要你的内存装的下，就是无限大。

id(变量名)：差看变量名对应值的内存地址

用法： id(对象或者对象名称(变量名))

n = 123
print(id(n))    # 结果 490299568-->内存地址

编码补充：

UTF-8编码：一个汉字 3个字节

GBK编码：一个汉字 2个字节

s = "哈哈"
for i in s:
    print(i)

显示结果：

分析：同样代码在2.7中打印不出来；但是控制台会输出6行空白(一个汉字，3个字节；2.7中按字节来遍历的)

        3.0中就没问题(3.0按字符来遍历的)

 

bytes():将字符转换成字节

和int  str 是同级别的；但是不属于基本类型。

可以将字符转换成字节

用法：

bytes(字符, encoding='utf-8')

分析：

字符：传入的要被转化的字符

encoding='utf-8':传入的字符的编码形式(这个很重要，不能写错)

name = "哈哈"
print(bytes(name, encoding="utf-8"))    # 结果显示 b'\xe5\x93\x88\xe5\x93\x88'
print(bytes(name, encoding="gbk"))  # 显示结果 b'\xb9\xfe\xb9\xfe'

显示结果：utf-8：一个汉字；3个字节   gbk：一个汉字；2个字节

和 for循环一起使用

s = "哈哈"
for i in s:
    print(i)
    print(bytes(i, encoding="utf-8"))

显示结果：

根据前面的设置，后面的显示结果是用16进制表示的二进制的字符串

但我们获取其转换后的字节码；然后进行循环

 

s = "哈哈"
for i in s:
    # 输出字符
    print(i)
    # 将字符转换成字节
    bytes_list = bytes(i, encoding="utf-8")
    print(bytes_list)  # 结果是16进制输出显示
    # 遍历得到的字节
    for b in bytes_list:
        # 如果输出每个元素，它会按10进制输出
        # bin():是将10进制转化成2进制
        print(b, bin(b))

结果显示：在 utf-8编码模式下

 

小技巧：将自己名字的二进制输出来

name = "王勇"
for i in name:
    name_bytes = bytes(i, encoding='utf-8')
    for b in name_bytes:
        print(bin(b))

结果显示：

思路梳理：

1. 3.5 for循环时，循环的每一个元素是“字符”

2. 字符 ==》 字节 ==》bytes()

bytes("字符, encoding="指定编码") ==》结果得到一个字节列表；默认是16进制表示的

因为不同编码指定的字节不同；所以的指定编码

utf-8 ：1个汉字 3个字节

gbk ： 1个汉字 2个字节

3. 用 for 循环得到的字节列表。将其打印 ==》结果是由10进制表示的-->一个整数

4. 将 10进制 ==》2进制：bin(10进制的数字) ==》显示2进制

 

字符串补充

 

str():里面可以串2个值；当串2个值的时候；第一个为字节编码；第二个为字节的编码格式(这个很重要不能写错)

下面代码为；字符和字节的转换

name = "哈哈"
b1 = bytes(name, encoding="utf-8")
b2 = bytes(name, encoding="gbk")
print(b1)  # 结果显示 b'\xe5\x93\x88\xe5\x93\x88'
print(b2)  # 显示结果 b'\xb9\xfe\xb9\xfe'

# 将字节转换为字符
s1 = str(b1, encoding="utf-8")
s2 = str(b2, encoding="gbk")
print(s1) # 结果 哈哈
print(s2) # 结果 哈哈

上面内容总结：

for 循环

1. 2.7中是按字节来循环

2. 3.0是按字符来循环的

3. 字符转字节用 bytes()

len()

1. 2.7中长度计算是按字节计算的 如：len("哈哈") 结果是 6

2. 3.0是按字符计算的     如：len("哈哈") 结果是 2

十进制==》二进制：bin()。

字符与字节之间的转换==》bytes()。

 

列表补充 list

 

可变的元素"集合"

功能：

1. 创建列表 如：li = list(["aa", "bb", "cc"])

2. 将其他对象转换成列表 -->对象必须是可迭代对象

 

字符串转化成列表

s = "你好"    # 能被for循环进行循环的就是可迭代对象
li = list(s) # 将字符串转化为列表
print(li)  # 结果：['你', '好']

元组转化成列表

t1 = ("haha", "jiyou", "sex")  # 元组t1
li = list(t1)  # 将元组转换成列表
print(li)  # 结果显示 ['haha', 'jiyou', 'sex']

字典转化成列表

d1 = {"name":"heihei", "age":12}    # 元组d1
li = list(d1)  # 将元组转换为列表
print(li)  # 结果 ['name', 'age']

# 为什么结果会是这样那？
# 因为字典的 for 循环直接打印是其中的key值
# 如果想打印value怎么办？

li_1 = list(d1.values())    # 将其中的value值转换为列表
print(li_1)  # 结果 [12, 'heihei']

# 我们再转换下
li_2 = list(d1.items()) # 获取字典的键值对
print(li_2) # 结果 [('name', 'heihei'), ('age', 12)]--》既然获取键值对当然打印也是打印键值对

注意：

1. 字典转化列表时；对其中 key 和 value 值和键值对 items 的处理；根据需要设置才能得到想要的结果

2. 根据上面例子我们得出结论；列表的转换，列表中的每个元素就是通过 for 循环；循环出来的对象。==》这就是本质，根源

多层嵌套

 例子：

# 需求：咋下面的列表中我要获得vv对应的那个123
li = ["haha", 123, {"v1":"k1", "v2":"k2", "k3":{"vv":123, "ii":456}}]
print(li[2]["k3"]["vv"])    # 结果 123

元组补充 tuple

功能：

1. 创建元组 如：tup = tuple(("haha", "heihei", "hehe"))

2. 转换元组

 

列表转换元组

li = ["haha", "heihei", "hehe"]
tup = tuple(li)     # 将列表转换为元组
print(tup) # 结果 ('haha', 'heihei', 'hehe')

总结：元组的转换和列表的转换一样；对象必须是可迭代对象

3.嵌套：元组虽然不能更改；但是可以嵌套。

问题：

那么元组不可修改的是什么？

元素(儿子元素)不可修改；但是元素里面的元素是可以修改的

t = (11, 22, ["haha", {"v1":"A56"}])
t2 = t[2]  # 获取元组中第三个元素-->是个列表
t2.append("heihei") # 向获取的列表增加元素
print(t)    # 结果 (11, 22, ['haha', {'v1': 'A56'}, 'heihei'])

针对元组tuple(元组)的不可变；进一步分析

前面我们看到了tuple一旦创建就不能修改。现在，我们来看一个“可变”的tuple：

t = ('a', 'b', ['A', 'B'])

注意到 t 有 3 个元素：'a'，'b'和一个list：['A', 'B']。list作为一个整体是tuple的第3个元素。list对象可以通过 t[2] 拿到：

然后，我们把list的两个元素改一改：

L = t[2]
L[0] = 'X'
L[1] = 'Y'

结果：

print t
('a', 'b', ['X', 'Y'])

图解分析：

结果图解：

总结：

1. 表面上看，tuple的元素确实变了，但其实变的不是 tuple 的元素，而是list的元素。

2. tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向'a'，就不能改成指向'b'，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！-->指向不变

3. 个人理解：就是元组的儿子不可变；其他后辈是可以变的。

练习：

需求：给下面的元组中的字典增加个 "v2":"B35"

t = (11, "hehe", ["haha", {"v1":"A56"}])
# 结果为 
t = (11, "hehe", ["haha", {"v1":"A56", "v2":"B35"}])

我的代码

t = (11, "hehe", ["haha", {"v1":"A56"}])
d = {"v2":"B35"}     # 将要定义的键值对存于一个字典并赋给 d
l2 = t[2]     # 获取元组中字典所在的项 ==》一个列表
t2 = l2[1]     # 再列表中获取字典
t2.update(d)     # 通过字典中更新的方式将要增加的内容更新进去 --> 这步等同于 t2.update({"v2":"B35"})
print(t)     # 结果 (11, 'hehe', ['haha', {'v2': 'B35', 'v1': 'A56'}])

给字典增加键值对的另一种方式：

t = (11, "hehe", ["haha", {"v1":"A56"}])
t2 = t[2][1]    # 获取字典
t2["v2"] =  "B35"    # 可以直接通过键和值将内容增加进去；如果v2由对应的值，则会把之前的值替换掉
print(t) # 结果 (11, 'hehe', ['haha', {'v2': 'B35', 'v1': 'A56'}]

总结：给字典增加键值对；可以直接通过将值赋给对应的键增加进去；如果键有对应的值，则会把之前的值替换掉

字典补充 dict

创建元组：d = dict(k1=123, k2=456) 或者 d = dict({"name":"heihei", "age":21}) 

注意：

1 如果字典要增加内容；可以直接 d(要增加的key值) = value(要增加的value值)

2 如果要修改的话；d(已有的key值) = value(要替换的新值)

字典也支持可迭代对象转换；但是操作却不一样

列表转换成字典

li = [11, 22, 33]
d = dict(li)
print(d)  # 结果报错

# 正确转换
d = dict(enumerate(li))
print(d)  # {0: 11, 1: 22, 2: 33}

# 并且可以控制key的顺序
d = dict(enumerate(li, 10))
print(d)  # {10: 11, 11: 22, 12: 33}

注意：我发现这样创建的字典元素是不会随机变动的；位置始终是固定的。

fromkeys(S, v=None): 

dic = {"k1":123, "k2":"456", "k3":111}

需求：将字典中的 k1，k2：拿出来；并让它们的值都为123

dic = {"k1":123, "k2":"456", "k3":111}
d = dic.fromkeys(["k1", "k2"], 123)
print(d)  # 结果{'k1': 123, 'k2': 123}

如果获取的key在字典中没有那？

dic = {"k1":123, "k2":"456", "k3":111}
d = dic.fromkeys(["k1", "k2", "k3"], 123) ==》这个等同与 d = dict.fromkeys(["k1", "k2", "k3"], 123)
print(d)  # 结果 {'k3': 123, 'k1': 123, 'k2': 123}

fromkeys产生的结果和我们普通创建的结果是一样的，但是，他们还是有区别的：-->本质区别

普通创建的：一个key对应的一个value值；并且在内存里他们的地址是不一样的

fromkeys创建的：他们key对应的value值在内存中的地址是一个地址；如果其中一个改变；其他也会变

n1 = dict.fromkeys(["k1", "k2", "k3"], [])
print(n1) # 结果 {"k1":[], "k2":[], "k3":[]}
n2 = {"k1":[], "k2":[], "k3":[]}
# 此时我们同时项 k1 对应的列表增加元素
n1["k1"].append("x")
n2["k1"].append("x")
print(n1)  # 结果 {'k2': ['x'], 'k3': ['x'], 'k1': ['x']}
print(n2)  # 结果 {'k2': [], 'k3': [], 'k1': ['x']}

类中方法的分析：

我们发现在哟的方法上面有一个 @staticmethod 有的没有

注意：这些都是类的方法；在python里面向对象对这些方法进行区分的。有的是类调用的；有的是对象调用的

有 @staticmethod ：是类调用的 如： 类.方法

无 @staticmethod ：是对象调用的 如： 对象.方法

具体更深入的在面向对象那章讲