python分支计算_python-运算、分支、深浅拷贝

算术表达式：

+ - * /

除法Python3中是默认向浮点数靠拢

//取整运算结果的最小整数靠拢向下

5 // 2 = 2(向下取整)

%取余运算

5 % 2 = 1

**幂值运算

2 ** 2 = 4

逻辑表达式

not aa的逻辑非bool

a and ba和b的逻辑与bool真真为真真假为假假假为假

a or b a和b的逻辑或bool真假为真真真为真假假为假

a is b a和b是同一个对象bool根据地址来判断

a is not b  a和b不是同一个对象bool

>>> mylist = []

>>> not a

False

>>> not mylist

True

>>> mylist本身是一个假

关系表达式

==等于这里只是单纯的判断数据元素

>>> mylist

[1, 2, 3, 4]

>>> mylist1

[1, 2, 3, 4]

>>> mylist1 == mylist

True

>>> 1 == 1

True

>>> 'abc' == 'abc'

True

!=不等于

>>> 2 != 1

True

<>不等于(废弃)

>>> 1 <> 2

True

>>> 3 <> 2

True

>>> 2 <> 2

False

>大于

>=大于等于

<=小于等于

逐位比较，如果第一位两个比较可以得出结果，那么后面的也不会继续比较了

>>> 'baa' < 'abb'

False

ascii码中大A和小a

ord(查看ascii码)

位运算

数据在内存中都是二进制，A a ->数字->二进制

正数1负数-1

原码0000 00011000 0001二进制最高位不是用来表示具体数字的，是用来表示符号位的

反码0000 0001正数的反码是其本身1111 1110符号位不变，其余各位取反

补码0000 0001正数的补码是其本身1111 1111补码是反码加一

补码是真正存储在计算机中的

计算机中存储-1存的其实是1111 1111

0000 0000八位的数最大能是多少(考虑符号的话)0 ~ 127

0000 0000 | 0000 0000 | 0000 0000| 0000 0000 | 0000 0000 | 0000 0000 | 0000 0000| 0000 0000 |

不考虑符号：最高位64  2**64  -  1

考虑符号：2**63  -  1

~a按位取反-(a+1)

1的补码0000 0001

-1的补码是1111 1111

正数0000 0001  1的原码补码，

1111 1110原码

1000 0001其余各位取反符号位不变反码

1000 0010  -2补码等于反码+1

-1 1111 1111补码

0000 0000

按位取反的公式：-(a+1)

a << n a左移n位

a >> n a右移n位

a & b a和b按位与

a | b a和b按位或

a^b a和b按位异或当a和b在位数上一个是0，一个是1的时候，结果得1，也就是位数相异，结果为1

0000            0000

128 64 32 16       8 4 2 1

按位与

0000 0001  1的补码

1111 1111 -1补码

0000 0001  1

按位或

0000 0001  1的补码

1111 1111 -1补码

1111 1111  -1

按位异或：

0000 0001  1的补码

1111 1111 -1补码

1111 1110

位相同返回0位不同返回1

负数求原码

1111 1101首先补码减一

1000 0010然后按位取反

正数不用求，补码即原码

分支语句：

and or

>>> a = 3

>>> b = 4

>>> c = ( a < b and a or b )

>>> c

3

如果a

Guido

>>> c = a if a < b else b

>>> c

3

如果a

if条件语句:

执行代码

条件语句必须是一个可以用bool值判断的

非空非0

空或0

>>> if a == 1:

...     print('a确实是等于1')

...

输出结果：a确实是等于1

>>> if a != 1:

...     print('a确实是不等于1')

...

没有输出

>>> if a == 1:

...     print('a == 1')

...   else:  #把所有之前判断条件没有判断到的地方这里都做了判断

...     print('a != 1')

之前的条件都没有满足那么else绝对会执行

>>> if a == 1:

...     print('a == 1')

... elif a == 2:

...     print('a == 2')

... elif a == 3:

...     print('a == 3')

... else:

...     print('a不等于123')

...

elif用来细化条件判断

else后不加条件语句

while循环

循环：和女朋友分分合合就是重复的做一些事情

while条件语句:

重复要做的事情

条件语句这里也是可用bool表示的

死循环ctrl+c

>>> sum = 0

>>> while mylist:

...     sum += mylist[0]   #求和

...     mylist = mylist[1:]  #这个地方我们切片,重新赋值

...

>>> sum

10

>>> mylist = [1,2,3,4]

>>> mylist = mylist[1:]

>>> mylist

[2, 3, 4]

for循环：

主要用来访问序列和可迭代的数据对象[1,2,3,4,5]

序列：列表，字符串，元组

for var in mystr：

print(var)

var变量名从序列mystr中一次次取值,

>>> mylist = [1,2,3,4]

>>> for i in mylist:

...     print(i)

...

1

2

3

4

for else:

for var in mylist:

print(var)

else:

print(‘123’)

如果说你的循环正常结束，那么就会执行else里的语句

>>> for var in mylist:

...     print(var)

... else:

...     print('循环正常结束了')

...

1

2

3

4

>>> while mylist:

...     print(mylist[0])

...     mylist = mylist[1:]

... else:

...     print('循环正常结束')

...

1

2

3

4

循环正常结束

break语句:

break语句用来终止循环语句，如果是用在嵌套循环中，break语句将停止执行最深层次的循环，并开始执行下一行代码

continue:

该语句跳出本次循环，跳过这次循环剩下的语句，进行下一轮循环，

>>> for var in mylist:

...     if var == 3:

...             break

...     print(var)

... else:

...     print('结束了')

...

1

2

>>> for var in mylist:

...     if var == 3:

...             continue

...     print(var)

... else:

...     print('end')

...

1

2

4

end

在使用continue语句跳过本次循环的时候，else语句还会正常执行

>>> for var in mylist:

...     print('------------')

...     print('外层循环的打印:',var)

...     for var in mylist1:

...             print('内层循环的打印:',var)

...

输出结果:

------------

外层循环的打印: 1

内层循环的打印: a

内层循环的打印: b

内层循环的打印: c

------------

外层循环的打印: 2

内层循环的打印: a

内层循环的打印: b

内层循环的打印: c

------------

外层循环的打印: 3

内层循环的打印: a

内层循环的打印: b

内层循环的打印: c

首先进行外层循环，然后向下会执行到内层循环，内层循环执行完之后，才能继续进行接下来的外层循环

深浅拷贝：

深拷贝和浅拷贝,python中一切皆对象，像数字，字符串，元祖，如果在内存中存储了这些元素，那么这块内存中的值是不可以被修改的，但是还存在一些可变对象，比如列表和字典，他们所占有的内存空间是可以修改的，有因为python中使用的是引用计数去节省内存。

引用：

>>> mylist

[1, 2, 3]

>>> mylist1 = mylist

>>> id(mylist1)

139642552222216

>>> id(mylist)

139642552222216

>>> mylist1[0] = 'a'

>>> mylist

['a', 2, 3]

>>> mylist1

['a', 2, 3]

拷贝：

>>> id(mylist)

139642552222216

>>> id(mylist1)

139642597865032

>>> mylist[0] = 1

>>> mylist1

['a', 2, 3]

>>> mylist

[1, 2, 3]

当你使用切片操作拷贝的时候，虽然我们可以修改外层列表，而且不影响其他列表，但是内层的子列表被修改的时候，却又都受到了影响

>>> mylist1 = mylist[:]

>>> mylist1

[1, 2, 3, ['a', 'b']]

>>> mylist

[1, 2, 3, ['a', 'b']]

>>> mylist[-1][0] = 1

>>> mylist

[1, 2, 3, [1, 'b']]

>>> mylist1

[1, 2, 3, [1, 'b']]

>>> mylist[0] = 'a'

>>> mylist

['a', 2, 3, [1, 'b']]

>>> mylist1

[1, 2, 3, [1, 'b']]

浅拷贝的方式:

浅拷贝不会拷贝数据中的子对象

import  copy

切片，copy()

深拷贝：

深拷贝会拷贝数据中的子对象

import  copy

copy.deepcopy()

拷贝构造器

a = A()

b = a #拷贝构造

拷贝构造器浅拷贝