Python基本数据类型解析

1基本数据类型

n1 = 123等同于  n1 = int(123)  根据int类型创建一个对象

int(123)类后面加上括号，等同于去类中执行  __init__   这个方法

    当然 str  list 等都有  __init__  这个方法

#下面的2，表示2进制

a = int('0b100',2)

0 = 0 

1 = 1

10 = 2

11 =3

100 = 4

print(a)  = 4 

 

在python中创建类

class  Myint():

        def __init__(self)

                print('init')

        drf call(self,*args,**kwargs)

                print("okok")

#当我们创建Myint()的对象的时候，系统会自动调用init方法，而在控制台打印出init

myint = Myint()

#下面会调用call方法  打印出okok

myint()

#python对内存的优化

#当变量中的值是从-5~257的时候，值为相同的情况，内存的指向也是相同的，python不会重新开辟内存地址

#如

a1 = 123

a2 = 123

a3 = 123

#等相同的值是不会重复的开辟内存地址，他们指向都是内存中相同的地址

#使用 id(变量名)可以查看内存中的地址

a = 123

a2 = 123

>>> id(a)
140730119057872
>>> id(a2)
140730119057872

# 当值大于257 内存地址不会相同

>>> a3 = 1234
>>> a4 = 1234
>>> id(a3)
2490258638736
>>> id(a4)
2490259600016

#int类型最大长度取决于操作系统的位数

#32位操作系统int长度 -2**31 ~2**31-1

#64位操作系统int长度 -2**63 ~2**63-1

#当int（整型字符串）超出了以上范围，python会自动将类型

#改为长整型在数字后面加上L字母

#long长整型不用担心长度，内存多大就会占多大。即int类型也不用去担心

#str 字符串

a1 = "gogoing"

#无参数 空字符串

#一个参数，创建普通字符串

#两个参数，int(字节，编码)

 

#字符串常用方法 

#去处两边空格

a1.strip()

#以。。。。开头

a1.startwith()

#查找子序列

a1.find()

#找到字符串中对应的子序列替换成指定字符串

a1.replace()

#变大写，验证码验证

a1.upper()

#是字母吗 是数字吗等情况

a1.isalpha()

#公共功能 索引  切片

a = "gogoing"

a[0]  = g #索引只能取一个元素

a[0:4] = "gogo"#切片能同时取多个元素

#补充 一个汉字 以utf-8编码，是占三个字节

#以gbk编码的，是占2个字节

#一个字节是八位 bit

#对于字节的解释  ：就是用16进制表示的2进制

a = '李娜'
for i in a :
# 此处打印出李娜
    print(i)
    b = bytes(i,encoding='utf-8')
#此处打印出16进制
    print(b)
    for c in b :
#此处打印出10 进制和2进制
        print(c,bin(c))

如下图 bin()方法将十进制转换成二进制

 #将字符串转换成字节
a = '琳娜'
b1 = bytes(a,encoding='utf-8')
b2 = bytes(a,encoding='gbk')
print(b1)
print(b2)
#再将字节转换成字符串
a1 = str(b1,'utf-8')
a2 = str(b2,'gbk')
print(a1)
print(a2)

#list元素集合的列表。

#创建列表，或者将转换成列表

#1将字符串转换成列表，事例（只要list中的参数是可迭代的，即可转换成集合）

#可迭代即是可 for循环的 

s1 = '张三'

li = list(s1)

#此时将s1转换成列表 =>li = ['李','；'露']

print(li)

#以上对字典进行转换中，如果只是放dic 会只转换字典的key值。因为字典默认循环的就是key，所以当你需要转换循环字典的哪#个值，就要取字典中对应的值 如：items() values() keys()等

#以下是对字符串、元祖、字典进行了集合的转换

>>> a = '留并'
>>> sd = list(a)
>>> print(sd)
['留', '并']
>>> a = ('asd','32','32dsd')
>>> sd = list(a)
>>> print(sd)
['asd', '32', '32dsd']
>>> a = {'k1':'v1','k2':'v2'}
>>> a
{'k1': 'v1', 'k2': 'v2'}
>>> sd = list(a)
>>> print(sd)
['k1', 'k2']
>>> sd = list(a.values())
>>> print(sd)
['v1', 'v2']
>>> sd = list(a.items())
>>> print(sd)
[('k1', 'v1'), ('k2', 'v2')]

#在学习中去发现，如果字符串的方法返回了一个新的对象，则这个方法没有改变原有的值，而是重新创建了一个新的值。

#如果这个方法不需要新的值接收，则这个方法改变了自身的值，如下：

a = 'gogog'

a.append('ing')

#此时改变了a本身的值

s = 'alex     '

sd = s.strip()

#没有改变s的值，只是创建了一个新的对象来接受改变过后的值

li = ['zhahg','liu','li']

#扩展自己，用另外一个可迭代对象，扩充到自己的内部 （可迭代的即可 可使用for循环）

li.extend()

#反转，自己内部元素反转

li.reverse()

#insert()向指定位置插入元素

li.insert()

#公共功能

#列表的公共功能 

li = ['lanqiu','zuqiu','paqiu','qiqiu']

索引：li[3] = > 'qiqiu'

切片: li[2:3] = > ['qiqiu']

#这里我们可以看出来，索引和切片的区别。索引只会去取单个字符串，而切片是会将对应的字符串取出后还放入我们现有的对

#象类型中进行保存

for   len 都可以使用

#如图 如果要去取字典中的123  使用

li[2][k2][vv]即可找到对应的123

#在列表中可以无限的嵌套各种值，每个元素都可以是任何值，字符串、数字、字典、元祖等

#元祖 元素不可修改

#tuple

同样有创建和转换的功能。转换的时候接受可迭代的数据

#元祖中元素不能变，元素的元素是可以变的

#如下 是可以改变元祖中元素的元素 。给字典中加入了一组新的元素

tu1 = ('zhang','li',['liu',{'k1':'v1'}])
k2 = {'k2':'123'}
tu1[2][1]['k2'] = 123
print(tu1)
tu1[2][1].update({"k4":"zhangsan"})
print(tu1)

结果：这两种方法都是可以使用的
=>('zhang', 'li', ['liu', {'k1': 'v1', 'k2': 123}])
=>('zhang', 'li', ['liu', {'k1': 'v1', 'k2': 123, 'k4': 'zhangsan'}])

知识点梳理：字符串执行了功能，就会生成新的内容，原来的内容不变。字典、元祖、列表等执行一个功能，一般都是自身进行了变化

#字典的创建,两种方式都可以

a = {"123":"333"}

a = dict(a=123,b=333)

#如何将一个列表转换成字典形式呢？

li = ['zhang','tai','li']

new_dic = dict(li)#直接放是会报错的，因为列表并没有键值对的形式存在

new_dic = dict(enumerate(li，10)) #这样enum会给li增加一个序号，让列表以键值对的形式出现

（内容手打，存在手误）