算术表达式:

+ - * /

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

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

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

%取余运算

5 % 2 = 1

**幂值运算

2 ** 2 = 4

逻辑表达式

not a a的逻辑非     bool

a and b ab的逻辑    bool 真真为真真假为假  假假为假

a or b ab的逻辑      bool  真假为真真真为真假假为假

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

a is not b  ab不是同一个对象  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 0001 1000 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 ab按位异或   ab在位数上一个是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  

位相同返回位不同返回1

负数求原码 

1111 1101 首先补码减一

1000 0010 然后按位取反

正数不用求,补码即原码

分支语句:

and or

>>> a = 3

>>> b = 4

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

>>> c

3

如果a<b成立,那么结果是a,反之是b

Guido 

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

>>> c

3

如果a<b成立,那么结果为a,否则结果是b

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 #拷贝构造

拷贝构造器浅拷贝

 

python-运算、分支、深浅拷贝的更多相关文章

  1. 第五篇python进阶之深浅拷贝

    目录 第五篇python进阶之深浅拷贝 一.引言 1.1可变 和不可变 二.拷贝(只针对可变数据类型) 三.浅拷贝 四.深拷贝 第五篇python进阶之深浅拷贝 一.引言 1.1可变 和不可变 id不 ...

  2. 天啦噜!仅仅5张图,彻底搞懂Python中的深浅拷贝

    Python中的深浅拷贝 在讲深浅拷贝之前,我们先重温一下 is 和==的区别. 在判断对象是否相等比较的时候我们可以用is 和 == is:比较两个对象的引用是否相同,即 它们的id 是否一样 == ...

  3. Python 中的深浅拷贝

    Python 中的深浅拷贝 参考文献:https://blog.csdn.net/lnotime/article/details/81194633 参考文献:https://blog.csdn.net ...

  4. Python基础【3】:Python中的深浅拷贝解析

    深浅拷贝 在研究Python的深浅拷贝区别前需要先弄清楚以下的一些基础概念: 变量--引用--对象(可变对象,不可变对象) 切片(序列化对象)--拷贝(深拷贝,浅拷贝) 我是铺垫~ 一.[变量--引用 ...

  5. python——赋值与深浅拷贝

    初学编程的小伙伴都会对于深浅拷贝的用法有些疑问,今天我们就结合python变量存储的特性从内存的角度来谈一谈赋值和深浅拷贝~~~ 预备知识一——python的变量及其存储 在详细的了解python中赋 ...

  6. Python中的深浅拷贝

    1.什么是深浅拷贝? python中一切皆对象,python中的数字.字符串.元组等,如果存放在了内存中,这部分内存里面的内容是不会改变的,但是也有情况,内存中存放了可变对象,比如说列表和字典,他们的 ...

  7. python基础(6)-深浅拷贝

    赋值 字符串和数字 # id()函数可以获取变量在内存中的地址标识 num1 = 2; num2 = 2; print(id(num1)) # result:8791124202560 print(i ...

  8. Python学习(006)-深浅拷贝及集合

     深浅拷贝 import copy husband=['xiaoxin',123,[200000,100000]] wife=husband.copy() #浅拷贝 wife[0]='xiaohong ...

  9. 人生苦短之我用Python篇(深浅拷贝、常用模块、内置函数)

    深浅拷贝 有时候,尤其是当你在处理可变对象时,你可能想要复制一个对象,然后对其做出一些改变而不希望影响原来的对象.这就是Python的copy所发挥作用的地方. 定义了当对你的类的实例调用copy.c ...

  10. 挖一挖python中的深浅拷贝问题

    前几天在做面试题的时候,遇到一个与Python深浅拷贝的问题,今天总结出来一个方法,能够快速判断在对一个对象复制后,新对象与原来对象是否会互相影响的方法. 先抛出结论,然后我们对结论进行验证~~~ 先 ...

随机推荐

  1. Exception in thread "main" java.lang.IllegalArgumentException: System memory 202768384 must be at least 4.718592E8. Please use a larger heap size.

    Spark-submit 提交任务时候报错 Exception in thread "main" java.lang.IllegalArgumentException: Syste ...

  2. swift tableViewController

    tableViewController 控制器 import UIKit     class ViewController: UITableViewController {              ...

  3. MyBatis 工作流程及插件开发

    1. MyBatis 框架分层架构 2. MyBatis 工作流程 获取 SqlSessionFactory 对象: 解析配置文件(全局映射,Sql映射文件)的每一个信息,并保存在Configurat ...

  4. linux创建lvm分区

    创建LVM分区 shell> fdisk /dev/xvdb #### 选择磁盘 Command (m for help): m #### 帮助 Command action a toggle ...

  5. Go学习笔记一:解析toml配置文件

    本文系作者原创,转载请注明出处https://www.cnblogs.com/sonofelice/p/9085291.html . 一些mysql或者日志路径的信息需要放在配置文件中.那么本博文主要 ...

  6. Mysql2索引

    索引分类: 作用:优化查询,select查询有三种情况:缓存查询(不在mysql中进行数据查询),全表查询,索引扫描 Btree(btree b+tree b*tree) Rtree HASH Ful ...

  7. Linux下多线程的重要知识点

    线程属性: typedef struct { int                              detachstate;   线程的分离状态 int                   ...

  8. bios设置启动方式问题

    uefi和legacy是两种不同的引导方式,uefi是新式的BIOS,legacy是传统BIOS.你在UEFI模式下安装的系统,只能用UEFI模式引导:同理,如果你是在Legacy模式下安装的系统,也 ...

  9. return的结果

    return只会返回第一个,接下去的不会再返回 所以return放在for里面用的话,即使循环好几次,但是除了循环的第一个,后面循环出来的结果都作废

  10. PHP魔术方法和魔术常量介绍及使用

    魔术方法(Magic methods) PHP中把以两个下划线__开头的方法称为魔术方法,这些方法在PHP中充当了举足轻重的作用. 魔术方法包括: __construct(),类的构造函数 __des ...