资讯专栏INFORMATION COLUMN

001_第一部分_[Python基础]

WrBug / 1283人阅读

摘要:一基础数据类型原始类型复合类型由其他原始类型组合起来的类型运算符和表达式算术运算符加减乘除取模幂地板除的除位运算符二进制之间的运算转换成二进制数将二进制转换成十进制按位与都为才为按位或存在即为按位异或相同的为不同的为按位取反正数的补码,反

一.python基础:

数据类型:

   
   原始类型:
   int float byte

   复合类型:
   由其他原始类型组合起来的类型
   list dict cuple 

运算符和表达式:

        算术运算符:
                加 / 减 / 乘 / 除 / 取模 / 幂 / 地板除
                +    -    *    /     %     **     //

        python2 的 除:
        10 / float(20)

        位运算符[二进制之间的运算]:
        bin(60) 转换成二进制数
        int("1100",2)   将二进制转换成十进制
        &    按位与        都为1 才为1    
        |    按位或         存在1 即为1
        ^    按位异或         相同的为0,不同的为1
        ~    按位取反         正数的补码,反码都是其本身
                        负数的补码是:符号位不变,其余各位求反,末位加1 ,既11111
                        反码是:符号位为1,其余各位求反,但末位不加1 ,既11110
                    
                        假设有一个数~9,计算步骤如下,9=1001
                        其补码为01001,
                        对其取反10110,这个数是在内存中存放的,现在需要装换成原码,既先减1,然后取反得 
                        11010,符号位为1是负数,既-10
        <<    左移
        >>  右移

按位取反:

    ---
    正数的补码和反码都是其本身,但是前面要加上正数的符号位 "0"
    ---
    负数的符号位是"1"
    负数的补码是:符号位不变,其余各位求反,末位加1
    负数的反码是:符号位不变,其余各位求反
    ---
    二进制数在内存中是以补码的形式存放的
    ---

    60的按位取反计算:
    
        第一步:
        计算60的 [补码] 和 [反码]:
    
                    原码    补码     反码
            十进制    60
            二进制    111100  0111100    0111100
    
    
        第二步:
        取反[取反操作是对补码进行取反]:
    
    
                            补码
                            1000011
    
                                    反码
                                    补码 - 1
                                    1000010
                    原码
                    1111101
                    1 代表是负数
                     111101 转换成十进制为61
                    -61

比较运算符[返回布尔类型]:

   ==    等于
   !=    不等于
   >   大于
   <   小于

逻辑运算符:

   
   and        与     同时True才为True
   or        或  只要存在True 则为True
   not     非  取反

   逻辑运算的短路功能:
   前面False后面就不会再计算:
   1+2 >4 and (2+2) == 4

   前面是True就不会再计算后面:
   1+2 <4 or (2+2) == 3 

---

   def add(x, y):
       print("%d + %d" %(x, y))
       return x+y
   add(1, 2) > 4 and add(2, 3) == 5
      ...: 
   1 + 2
   Out[2]: False

---

   def add(x, y):
       print("%d + %d" % (x, y))
       return x+y
   add(1, 2) < 4 and add(2,3) < 6
      ...: 
   1 + 2
   2 + 3
   True

---

   def add(x, y):
       print("%d + %d" % (x, y))
       return x+y
   add(1, 2) < 4 and add(2,3) < 4
      ...: 
   1 + 2
   2 + 3
   False

其他运算符:

    =        赋值运算符
    in         成员运算符
    not in     成员运算符
    is         身份运算符, 比较两个元素的id; 列表不能用is 做比较
    is not     身份运算符
            is 使用的环境经常拿来判断是不是None;

表达式与优先级:

        1. 一元高于二元
        2. 数值高于逻辑
        3. 算术运算高于位运算
        4. 乘除高于加减
        5. 拿不准时加括号

程序结构:

        1.    顺序结构
        2.    分支结构
        3.    循环结构

        关于 SWITCH
        Python中并没有switch结构,因为"switch"结构完全可以由"if elif else"语句来实现
        
        switch实现方法:
        粗糙版:
        #coding:utf8  
        #add minus divide using python  
        from __future__ import division  
        x=1  
        y=2  
        operator="/"  
        result={  
        "+":x+y,  
        "-":x-y,  
        "*":x*y,  
        "/":x/y  
        }  
        print(result.get(operator))         

        改进版:
        #!/usr/bin/env python
        # -*- encoding:utf-8 -*-
        
        class calculate:
            def __init__(self, x, op, y):
                self.x = x
                self.op = op
                self.y = y
        
            def count(self):
                result={
                "+":self.x+self.y,
                "-":self.x-self.y,
                "*":self.x*self.y,
                "/":self.x/self.y}
                print(result.get(self.op))
        
        mark = calculate(10,"+",2)
        mark.count()

python的三元运算

        a = 4
        b = a if a > 0 else 0

RANGE函数

        range(x)         [0,x)
        range(m, n)     [m, n)
        range(m, n, s)    [m,n),步长为s

break 子句

        * 只能出现在循环结构中
        * 用于跳出当前循环结构

continue子句:

        * 只能出现在循环结构中
        * 用于跳过此次迭代的剩余操作

else子句:

        循环结构的else子句是python特有的,用于表示一个循环不是经过"break"跳出循环,提前结束循环,而是正常退出的,才会执行else中的语句;
二.内置容器:

列表

        * list是最常用的线性数据结构
        * list是一系列元素的有序组合
        * list是可变的
        
        列表的操作:
        定义列表:
        li = []
        li = list()
        li = [1, 2, 3]

        查看帮助文档:
        help(list)
        增:append, extend, insert
        删:clear, pop, remove
        改:reverse, sort
        查:count, index
        其他:copy

        增:
        li = []
        append:只能一个一个增加
        li.append(3)
        
        extend:扩展
        li.extend([5,6,7])
        li
        [3, 5, 6, 7]

        insert:位置之前插入
        li.insert(0, 0) 在第一个之前插入0

        删:
        clear:清空列表
        li.clear()

        remove:从左开始删除指定元素一个,如果删除的元素不存在会报错ValueError
        li.remove(3)  删除元素3
        
        pop:删除指定位置元素:如果不存在会报错IndexError
        li.pop()    删除最后一个元素
        li.pop(3)   删除key是3的元素

        改:
        reverse:颠倒列表顺序:
        sort:从小到大排序:    仅用于简单数字排序
        sort(reverse=True) 从大到小排序:

        查:
        count:显示匹配元素个数
        li.count(3)
        
        其他:
        index(3):返回指定元素在列表中的位置;如果不存在会报ValueError:
        index(value, [start, [stop]]) 

        copy: 深拷贝,会生成一个新的list
                赋值是浅拷贝,浅拷贝的数据修改会对原来的list产生影响;

        下标操作:
        li[1]
        
        li[1] = 10

        切片:
        li[3:5]:  前面是闭区间  后面是开区间
        li[3:]
        li[:]  效果和copy是一样的,效率会比copy快;
        li[:4] 
        li[4:-2]     切到倒数第二个;后面是开区间
        li[-4:-1]
        li[2:6:2]:    start, stop ,步长
        li[6:2:-1]  start,stop ,反向显示,步长为1
        li[6:2:-2]    start,stop,反向显示,步长为2
        li[::-1]
        li[::2]

元组[tuple]:

        tuple和list大多数地方类似
        tuple是不可变结构
        tuple只能获取值

        定义一个元组:
        t = ()
        t = tuple()

        count:统计元素个数
        index:返回指定元素在元组中的位置

        下标操作[通过下标获取value]:
        t[1]

* PACKING & UNPACKING

        PACKING        :把多个变量的值变成一个元组或者列表,默认是变成元组
        UNPACKING    :也可以把一个元组或者列表赋值给多个变量

    ---
        x, *y = (1, 2, 3, 4)
        print(x)
        1
        print(y)
        [2, 3, 4]

    ---
        *x, y = (1, 2, 3, 4)
        print(x)
        [1, 2, 3]
        print(y)
        4

    ---
        *_ 这个表示赋值给一个不能用的变量:

        x, *_, y = (1, 2, 3, 4)
        print(x)
        1
        print(y)
        4
        
    ---
        x, (y, z) = (1, (2, 3))
        print(x)
        1
        print(y)
        2
        print(z)
        3

    ---

集合:

        集合的含义和数学上集合的含义相同
        集合不是线性结构
        * 集合元素是唯一的
        集合元素是可hash的
        
        集合的操作:
        初始化:
        s = set()
        s = set([1, 2, 3])

        增:
        s.add(3)                     //添加一个元素
        s.update([3, 4, 5, 6])        //集合添加list中的多个元素

        删:
        remove:        删除,删除不存在的元素会抛出异常;
        discard:    删除,删除不存在的元素不会抛出异常;
        clear:        清空
        pop:        随机删除集合中的一个元素
        
        集合运算:
        union                    并集              a | b
        intersection            交集              a & b
        difference                差集,不可交换的    a - b
        symmetric_difference    集合之差的并集       a ^ b

        集合判断[返回布尔值]:
        issubset    子集
        issuperset    超集
        isdisjoint    

字典:

        * 字典是一种无序集合
        * 字典是一种KV结构
        * value可以是任何对象
        * key是唯一的
        * key必须是可hash对象

        字典的操作:
        d = dict()
        d = {"a":5, "b":4}
        d["a"]
        
        d.keys()
        dict_keys(["b", "a"])

        遍历 key:
        for key in d.keys():
            print(d[key])

        遍历 value:
        for value in d.values():
            print(value)

        遍历key和value:
        for key,value in d.iterms():
            print(key, value)
            print("%s => %s" %(key, value))

        d.iterkeys()    返回的是一个生成器;
        
        pop,popitem     用于删除元素
        d.pop("key")    需要指定key,删除不存在的值返回KeyError
        d.pop("key",6)    删除不存在的值将返回 6
        
        增加字典元素:
        d["c"] = 7

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/37792.html

相关文章

  • 002_一部_[字典 / 列表解析 / 字符串操作 / STR与BYTES的区别 ]

    摘要:一字典定义字典获取元素这两个的区别用在不存在的时候不会抛出设置当不存在的时候返回的内容增加和修改元素修改和增加元素的方法都是这个删除元素删除的同时返回删除的内容如果删除不存在的会报这个时候就需要给定返回值这样返回的就是不会报错误从字典中随机 一.字典: 定义字典:d = {}d = dict()d = {a:1, b:2} 1.获取元素: d[a] d.get(a) >这两个的区别,用...

    CastlePeaK 评论0 收藏0
  • Pandas之旅(五): 构建模型初入门:检验数据一致性

    摘要:如何根据需要创建简单模型大家好,今天这一期我想和大家分享有关于创建模型的部分,首先让我们来看一个比较常见的场景你每天需要打开个进行相同的操作,各种眼花缭乱的函数后老眼昏花。。。。 Pandas 如何根据需要创建简单模型 大家好,今天这一期我想和大家分享有关于pandas创建模型的部分,首先让我们来看一个比较常见的场景: 你每天需要打开N个excel进行相同的操作,各种眼花缭乱的VBA函...

    hqman 评论0 收藏0
  • 从零开始使用TensorFlow建立简单的逻辑回归模型

    摘要:我们使用的损失函数为由于我们的数据集只有两个特征,因此不用担心过拟合,所以损失函数里的正规化项就不要了。到此,一个完整的简单的逻辑回归模型就实现完毕了,希望通过这篇文章,能让各位看官对在中机器学习模型的实现有一个初步的了解。 TensorFlow 是一个基于 python 的机器学习框架。在 Coursera 上学习了逻辑回归的课程内容后,想把在 MATLAB 中实现了的内容用 Ten...

    kohoh_ 评论0 收藏0
  • Flask Web Development —— 大型应用程序结构(下)

    摘要:单元测试这个应用非常小以至于不需要太多的测试,但是作为示例会在示例中展示两个简单的测试定义。示例单元测试编写好的测试使用的是来自于标准库中标准的包。为了运行单元测试,可以在脚本中增加一个自定义的命令。 4、启动脚本 顶层目录中的manage.py文件用于启动应用。这个脚本会在示例7-8中展示。 示例7-8. manage.py:启动脚本 #!/usr/bin/env python im...

    whidy 评论0 收藏0

发表评论

0条评论

WrBug

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<