python之路,Python基础篇2(

发布时间:2019-08-20 08:03:01编辑:auto阅读(985)

    一、.pyc是个什么鬼:
    	pyc文件其实是PyCodeObject的一种持久化保存方式。
    
    二、数据类型
    
    1、数字:
    	2 是一个整数的例子。
    	长整数 不过是大一些的整数。
    	3.23和52.3E-4是浮点数的例子。E标记表示10的幂。在这里,52.3E-4表示52.3 * 10-4。
    	(-5+4j)和(2.3-4.6j)是复数的例子,其中-5,4为实数,j为虚数,数学中表示复数是什么?
    
    int(整型)
      在32位机器上,整数的位数为32位,取值范围为-2**31~2**31-1,即-2147483648~2147483647
      在64位系统上,整数的位数为64位,取值范围为-2**63~2**63-1,即-9223372036854775808~9223372036854775807
    long(长整型)
      跟C语言不同,Python的长整数没有指定位宽,即:Python没有限制长整数数值的大小,但实际上由于机器内存有限,我们使用的长整数数值不可能无限大。
      注意,自从Python2.2起,如果整数发生溢出,Python会自动将整数数据转换为长整数,所以如今在长整数数据后面不加字母L也不会导致严重后果了。
    float(浮点型)
      浮点数用来处理实数,即带有小数的数字。类似于C语言中的double类型,占8个字节(64位),其中52位表示底,11位表示指数,剩下的一位表示符号。
    complex(复数)
      复数由实数部分和虚数部分组成,一般形式为x+yj,其中的x是复数的实数部分,y是复数的虚数部分,这里的x和y都是实数。
    注:Python中存在小数字池:-5 ~ 257
    
    
    #复数,生产环境用得比较少。
    python 2.7 有整型和长整型之分:
    
    	>>> (2) -1
    	1
    	>>> (2**31) -1
    	2147483647L
    	>>>
    
    	>>> type( (2**30) -1)
    	<type 'int'>
    	>>> type( (2**31) -1)
    	<type 'long'>
    	>>>
    
    python 3.x 没有整型和长整型之分:
    
    	>>> type( (2**30) -1)
    	<class 'int'>
    	>>> type( (2**31) -1)
    	<class 'int'>
    	>>>
    
    2、布尔值
    
    	真或假
    	1 或 0
    	
    	>>> 1 is True
    	False
    	>>> 0 is False
    	False
    	>>> 0 is True
    	False
    
    3、字符串
    
    	"hello world"
    
    	万恶的字符串拼接:
    	python中的字符串在C语言中体现为是一个字符数组,每次创建字符串时候需要在内存中开辟一块连续的空,并且一旦需要修改字符串的话,就需要再次开辟空间,万恶的+号每出现一次就会在内从中重新开辟一块空间。
    
    	>>> name = 'luchuan'
    	>>> print("my name is " + name + " and you ? ")
    	my name is luchuan and you ?
    	>>>
    
    #这等于三块内存空间
    
    字符串格式化输出
    
    	name = "luchuan"
    	print "i am %s " % name
    
    #输出: i am luchuan
    
    PS: 字符串是 %s;整数 %d;浮点数%f
    
    字符串常用功能:
    	移除空白
    	分割
    	长度
    	索引
    	切片
    
    1)strip 移除空白
    	username = input("user:")
    	if username.strip() == 'alex':
    		print("welcome")
    
    2)split 分割
    	name = "alex,jack,rain"
    	name2 = name.split(",")
    	print(name2)
    
    3)join 字符串合起来
    	name = "alex,jack,rain"
    	name2 = name.split(",")
    	print("|".join(name2))
    
    4)‘’ in name 判断有没有空格
    	name="alex li"
    	print('' in name)
    
    5)capitalize 首字母大写
    	name="alex li"
    	print(name.capitalize())
    
    6)format 格式化
    	msg = "Hello, {name}, it's been a long {age} since last time sopke..."
    	msg2 = msg.format(name='xiaoming',age=33)
    	print(msg2)
    
    	msg2 = "haha{0}, dddd{1}"
    	print(msg2.format('Alex',33))
    
    7)center 居中
    	name="alex li"
    	print(name.center(40,'-'))
    
    8)find 查找
    	name = 'alex3sdf'
    	print(name.find('a'))
    
    9)isdigit是否是数字
    	age = input("your age:")
    	if age.isdigit():
    		age = int(age)
    		print(age)
    	else:
    		print("invalid data type")
    	
    10)isalnum 是否只包含字母数字字符
    	name = 'alex3sdf'
    	print(name.isalnum())
    
    11)endswith 什么时候结尾
    	name = 'alex3sdf'
    	print(name.endswith('df'))
    
    12)startswith 什么时候开始
    	name = 'alex3sdf'
    	print(name.startswith('df'))
    
    13)upper 大写
    	name = 'alex3sdf'
    	print(name.upper())
    
    14)lower 小写
    	name = 'alex3sdf'
    	print(name.upper().lower())
    15)len 长度
    	print(len(name))
    
    4、列表
    python包含6种内建的序列:列表、元组、字符串、Unicode字符串、buffer对象和xrange对象。
    列表只有在Python中叫列表,在其他语言中叫数组。
    索引是访问单个元素,分片操作是访问一定范围内的元素
    
    创建列表:	
    
    	name_list = ['alex', 'seven', 'eric']
    	或
    	name_list = list(['alex', 'seven', 'eric'])
    
    基本操作:
    
    索引
    切片
    追加
    删除
    长度
    循环
    包含
    
    
    name = ['Alex', 'jack', 'Rain', 'Eric', 'Monica', 'Fiona']
    >>> name[:]
    ['Alex', 'jack', 'Rain', 'Eric', 'Monica', 'Fiona']
    
    
    索引
    >>> name[2]
    'Rain'
    
    切片
    >>> name[2:4]
    ['Rain', 'Eric']
    >>> name[2:4][0]
    'Rain'
    >>> name[2:4][0][1:2]
    'a'
    
    修改:
    >>> name[1]="xiaoming"
    >>> name
    ['Alex', 'xiaoming', 'Rain', 'Eric', 'Monica', 'Fiona']
    
    插入:
    >>> name.insert(2,'daming')
    >>> name
    ['Alex', 'xiaoming', 'daming', 'Rain', 'Eric', 'Monica', 'Fiona']
    
    追加:
    >>> name.append('alex')
    >>> name
    ['Alex', 'xiaoming', 'daming', 'Rain', 'Eric', 'Monica', 'Fiona', 'alex']
    
    删除:
    >>> name.remove("daming")
    >>> name
    ['Alex', 'xiaoming', 'Rain', 'Eric', 'Monica', 'Fiona', 'alex']
    
    练习:
    往中间插入两个临组成员的名字
    取出第3-8的人列表
    删除第9个人
    把刚才加入的那2个其他组的人一次性删除
    把组长的名字加上组长备注
    要求你隔一个人打印一个人
    
    >>> name = ['Alex', 'xiaoming', 'Rain', 'Eric', 'Monica', 'Fiona']
    
    >>> name.insert(-1,"xiaochuan")
    >>> name.insert(5,"dachuan")
    
    >>> name[3:8]
    ['Eric', 'Monica', 'dachuan', 'xiaochuan', 'Fiona']
    
    >>> name.remove("Fiona")
    >>> name
    ['Alex', 'xiaoming', 'Rain', 'Eric', 'Monica', 'dachuan', 'Fiona']
    
    >>> del name[4:6]
    
    >>> print(name[::2])
    
    长度:
    >>> len(name)
    7
    >>> name
    ['Alex', 'xiaoming', 'Rain', 'Eric', 'Monica', 'Fiona', 'alex']
    
    5、元组(不可变列表)
    	创建元组:
    
    	ages = (11, 22, 33, 44, 55)
    	或
    	ages = tuple((11, 22, 33, 44, 55))
    
    6、字典(无序)
    	创建字典:
    	person = {"name": "mr.wu", 'age': 18}
    	或
    	person = dict({"name": "mr.wu", 'age': 18})
    
    常用操作:
    
    索引
    新增
    删除
    键、值、键值对
    循环
    长度
    
    为什么要有字典呢?是因为序列的不足。
    字典:
    	1、查看
    	2、修改:
    	3、添加:
    	4、删除:
    	5、获取:
    	6、update更新:
    	7、items:
    	8、values:
    	9、keys:
    	10、has_key:
    	11、setdefault:
    	12、fromkeys:
    	13、popitem:
    	
    id_db = {
        371471199306143632:{
            'name':"Alex Li",
            'age':22,
            'addr':'ShanDong'
        },
        22043549306143632:{
            'name':"ShanPao",
            'age':24,
            'addr':'DongBei'
        }
    }
    
    查看:
    print(id_db[22043549306143632])
    
    修改:
    print(id_db[22043549306143632])
    id_db[22043549306143632]['name']="xiaoming"
    print(id_db[22043549306143632])
    
    添加:
    print(id_db[22043549306143632])
    id_db[22043549306143632]['name']="xiaoming"
    id_db[22043549306143632]['qq_of_wife']=38232354
    print(id_db[22043549306143632])
    
    删除:
    print(id_db[22043549306143632])
    id_db[22043549306143632]['name']="xiaoming"
    id_db[22043549306143632]['qq_of_wife']=38232354
    del id_db[22043549306143632]['addr']
    print(id_db[22043549306143632])
    
    print(id_db[22043549306143632])
    id_db[22043549306143632]['name']="xiaoming"
    id_db[22043549306143632]['qq_of_wife']=38232354
    id_db[22043549306143632].pop("addr")
    print(id_db[22043549306143632])
    
    获取:
    v = id_db.get(22043549306143632)
    print(v)
    
    	如果没有这个值,返回none:
    	v = id_db.get(22343549306143632)
    	print(v)
    	None
    	
    	这样取值会报错:
    	v = id_db[22343549306143632]
    	print(v)
    
    
    update更新:
    id_db = {
        371471199306143632:{
            'name':"Alex Li",
            'age':22,
            'addr':'ShanDong'
        },
        22043549306143632:{
            'name':"ShanPao",
            'age':24,
            'addr':'DongBei'
        }
    }
    
    dic2 = {
        'name':'dssfdsfsf',
        220435493061436532: {
            'name':"DaShanPao",
            'age':24,
            'addr':'DongBei'
        }
    }
    
    id_db.update(dic2)
    print(id_db)
    
    items:
    把字典变成列表,数据量大得情况下,尽量不要使用。
    print(id_db)
    print(id_db.items())
    
    values:
    打印字典里所有的values
    print(id_db)
    #print(id_db.items())
    print(id_db.values())
    
    keys:
    打印字典里所有的keys:
    print(id_db.keys())
    
    has_key:
    id_db.has_key(371471199306143632) #only in 2.x
    371471199306143632 in id_db # equals to above has key(x)
    
    setdefault:
    如果有那个值,就取出,没有就在后面赋值:
    print(id_db.setdefault(371471199306143632),"hahha")
    print(id_db)
    
    fromkeys:这是个坑,有问题再问。
    print(id_db.fromkeys([1,2,34,4,5,6],'ddd'))
    
    popitem:随机删除一个key,不要使用:
    print(id_db.popitem())
    print(id_db)
    
    循环一个字典:
    #for k,v in id.items(): #效率低,因为要有一个dict to list 的转换过程
    #	print(k,v)
    	
    for key in id_db:
    	print(key,id_db[key])
    
    三、数据运算
    
    	计算机中能表示的最小单位,是一个二进制位。
    	计算机中能存储的最小单位,是一个二进制位(bit)。
    	8bit = byte(字节)
    	1024byte = 1kbyte
    	1024kbyte = 1mbyte
    	1024mb = 1gb
    	1024gb = 1T
    
    算数运算:
    比较运算:
    赋值运算:
    逻辑运算:
    成员运算:
    身份运算:
    位运算:
    四、set集合应用
    
    set集合应用:set集合在爬虫和CMBD中都有用到。
    set集合:无序、不重复、可嵌套
    li = []
    list((11,22,33,4))
    # list__init__,内部执行for循环(11,22,33,4) [11,22,33,4]
    
    #创建集合
    # s1 = {11,22}
    # s2 = set()  #空集合
    # s3 = set([11,22,33,4])
    
    ## 操作集合
    # s = set()
    # print(s)
    # s.add(123)
    # s.add(123)
    # s.add(123)
    # print(s)
    # s.clear()
    # print(s)
    # s1 = {11,22,33}
    # s2 = {22,33,44}
    # s3 = s1.difference(s2)
    # A中存在,B中不存在
    # s3 = s2.difference(s1)
    # s3 = s1.symmetric_difference(s2)
    # print(s1)
    # print(s2)
    # print(s3)
    # s1.difference_update(s2)
    # s1.symmetric_difference_update(s2)
    # print(s1)
    # s1 = {11,22,33}
    # s2 = {22,33,44}
    # s3 = s1.union(s2)
    # print(s3)
    # s3 = s1.intersection(s2)
    # s1.intersection_update(s2)
    # print(s3)
    
    删除:
    
    s1 = {11,22,33}
    # s1.discard(1111)
    # s1.remove(11111)
    s1.pop()
    print(s1)
    discard 移除某个元素,如果没有那个元素,不报错
    remove 移除某个元素,如果没有那个元素,报错
    pop 随机移除元素,pop内部不能加参数
    
    但凡有带双下划线得都是有特殊意义得:
    # li = [11,22,33] # list __init__
    # li()            # list __call__
    # li[0]           # list __getitem__
    # li[0] = 123     # list __setitem__
    # def li[1]       # list __delitem__
    
    set集合练习:
    寻找差异:
    new_dict = {
        "#1": 4,
        "#2": 4,
        "#3": 2,
    }
    
    old_dict = {
    	"#1":8,
    	"#2":4,
    	"#4":2,
    }
    
    # old_kyes = old_dict.keys()
    # old_set = set(old_kyes)
    new_set = set(new_dict.keys())
    old_set = set(old_dict.keys())
    remove_set = old_set.difference(new_set)
    add_set = new_set.difference(old_set)
    update_set = old_set.intersection(new_set)
    
    
    # 数据库中原有
    old_dict = {
        "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 },
        "#2":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
        "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
    }
      
    # cmdb 新汇报的数据
    new_dict = {
        "#1":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 800 },
        "#3":{ 'hostname':c1, 'cpu_count': 2, 'mem_capicity': 80 }
        "#4":{ 'hostname':c2, 'cpu_count': 2, 'mem_capicity': 80 }
    }
    需要删除:?
    需要新建:?
    需要更新:? 
    注意:无需考虑内部元素是否改变,只要原来存在,新汇报也存在,就是需要更新


关键字