001第一部分[python基础]

Posted 2020-06-19

一.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

本文出自 “技术小菜” 博客，谢绝转载！