学习--->更新集合/内存/深浅拷贝

2019-04-11 10:28:30来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

 一、计算机基础

1..软件(应用程序)

2.解释器/编译器

- 解释型语言:将代码每一行传递给计算机一行,常用编程语言python,PHP,Ruby。

- 编译型语言:将代码完全执行完后会形成一个文件把结果传递给计算机,常用编程语言C, C++, C#, Java, Go语言。

3.操作系统

- Windows :价格昂贵

-xp,win7,win8,win10,Windows server

- Linux

  -centos 免费,图形画面差

  -Ubuntu 个人开发,图形画面较好

  -Redhat 企业级

  -Mac :办公

4.硬件: CPU,硬盘,内存,显卡等

二、环境变量

1.python解释器

- python2

- python3

2.开发工具:pycharm(推荐)/文本编辑

三、python语法

1.解释器安装路径 (Linux操作系统需要增加如下例子中第一行代码)

- linux系统应用:
- 赋予文件可执行权限
- ./hello.py

        #!/usr/bin/env python
        print(“你好”)

2.编码

1.编码种类

- ASCII :8位=1字节

- Unicode:32位=4字节

- utf-8/utf-16:最少1字节,最多4字节

-GBK/GB2312

2.中文

- Unicode :4字节

- utf-8/utf-16 : 3字节

- GBK/GB2312 : 2字节

3.默认编码

- py2 默认解释器编码为ASCII码

- py3 默认解释器编码为utf-8

4.以什么编码保存,以什么编码读取。 

3.输入输出

1. py2:

- 输入:num = raw_input("王老五")

- 输出:print "王老五"     # print后加空格

2 . py3:

- 输入:num=input("王老五")

- 输出:print("王老五")

4.数据类型        (type(v)可以查看v的数据类型)

1.整型(int)

- py2:

  - 位数有限超出后自动转换成long

  - 做除法时,结果取整数部分,增加

               from __future__ import division

 

- py3:

  - 只有int

  - 做除法时,可以获得完整结果

  - 强制转换 int()

2.布尔值(bool/boolen)

- True 

- False:数字中只有0是False,字符串中只有""(空字符)是False。

3.字符串(str):属于不可变类型,所以不能删除和修改.

1.字符串方法

- 大小写转换:upper / lower

a="adadHJHJ"
b=a.upper()
print (b)

- 判断是否为数字:isdiigit

a="dad55SFAF"
a=a.isdigit()
print(a)    
输出结果:

- 清空空格 :strip / lstrip / rstrip    # 还可以清空换行符

a="   王老五    "
a=a.split()
print(a)
输出结果:      

- 替换 :replace

# 例一:
a="王老五是个大烧饼" b=a.replace("烧饼","**") print(b)
输出结果:       

 

  #例二

a="王老五是个大烧饼,我说他是烧饼他就是烧饼"
b=a.replace("烧饼","**",2)
print(b)
输出结果:       

- 分割 :split / rsplit  (分割后的序列是列表形式)

a="王老五是个大烧饼我说他是烧饼他就是烧饼"
b=a.split("烧饼",2)
print(b)
输出结果:       

- 以什么开头/结尾:startswith/endswith

a="烧饼就是王老五"
b=a.startswith("烧饼")
print(b)
输出结果:       

- 格式化:format

a="王老五是个大{0},活了{1}年了"
b=a.format("烧饼",26)
print(b)
输出结果:       

- 转换编码类型:encode

a="王老五"
b=a.encode("utf-8")
print(b)
输出结果:       

- 插入:join  

a="王老五是个大烧饼"
b="**".join(a)   # 在每个元素中间插入**  要保证加入的是字符串格式,被插入的序列可以是其他格式,例:可以是列表 , 但列表内必须全部都是字符串
print(b)
输出结果:        

2.字符串公共方法

- 计算长度:len

a="王老五是个大烧饼"
b=len(a)
print(b)
输出结果:        

- 索引

a="王老五是个大烧饼"
print(a[2])        # 注:第一个元素从0开始,-1是最后一个元素也就是从右向左第一个元素.
输出结果        

- 切片

a="王老五是个大烧饼"
print(a[-3:])     # 后面不写是到达正无穷
print(a[0:3])     # 左闭右开
print(a[:3]) # 前面不写是从负无穷开始
输出结果        

- 步长

a="dajkj56uja"
print(a[::2])     # 2代表的就是步长,两个去一个,即隔一个去一个
print(a[0:6:1])   
print(a[:8:3])
输出结果       

- for循环

a="王老五是个大烧饼"
for b in a:       # 依次循环a中每个元素,并赋值给b
  print (b)
输出结果       

- range  :  range(0,10)/range(0,10,1), 左闭右开 , 自动生成[0,1,2,3,4,5,6,7,8,9]的一个列表, range 如果需要生成一个倒序的列表 , 则range( 10 , -1 , -1), 其中第三位数字表示的是每次递增或递减多少 . 

for a in range(9,-1,-1)
    print(a)
输出结果        

 

  4.列表(list) :属于可变类型  a=[1,'a',True,[2,3,4]]

  1.列表的方法

  - append : 在列表最后插入一个元素

a=[1,'a',True,[2,3,4]]
a.append("王老五大烧饼")
print(a)
输出结果        

  - insert : 在索引指定位置前面插入元素

a=[1,'a',True,[2,3,4]]
a.insert(2,"seven")
print(a)
输出结果        

  - remove   删除指定元素

a=[1,'a',True,[2,3,4]]
a.remove("a")
print(a)
输出结果         

  - pop  删除索引位置元素, 还可以把删除的元素给到一个新的变量 . 

a=[1,'a',True,[2,3,4]]
b=a.pop(2)
print(a)
print(b)
输出结果        

 

  - clear  清空所有

a=[1,'a',True,[2,3,4]]
a.clear()
print(a)
输出结果         

  - extend  扩展 : 在列表末尾追加一个序列的多个值 . 可以是列表也可以是字符串 . 

a=["王老五","大烧饼","jklj","True"]
b="qwer"
c=["jkl","hjjk","学生","oldboy"]
d=("dada","达到")
e={"dad":"455","学号":"456"}
a.extend(b)
print(a)
a.extend(c)
print(a)
a.extend(d)
print(a)
print(a)
输出结果       

  - reverse : 反转

a=["王老五","大烧饼","jklj","True"]
a.reverse()
print(a)
输出结果        

 

  - sort : 排序

a=[1,3,5,9,8,6]
a.sort(reverse=False)     # 从小到大排序 ,默认从小到大
print(a)
输出结果          
a=[1,3,5,9,8,6]
a.sort(reverse=True) # 从大到小排序
print(a)
输出结果          

 

  2.列表公共方法

    - 计算长度:len

a=["dad",32,"王老五",True]
b=len(a)
print(a)

    - 索引

a=["dad",32,"王老五",True]
b=a[2]
c=a[0][2]
print(b)
print(c)
输出结果       

    - 切片

a=["dadgjgj",32465465,"王老五",True]
b=a[1:3]
c=a[0:3][2]
print(b)
print(c)
输出结果       

    - 删除 :del    del也可进行切片删除

a=[1,'a',True,[2,3,4]]
del a[2]
print(a)
输出结果           
a=[1,'a',True,[2,3,4]]
del a[0:3]
print(a)
输出结果           

    - 修改

a=[1,'a',True,[2,3,4]]
a[2]="大烧饼"
print(a)
输出结果          

    - 步长

a=["dadgjgj",32465465,"王老五",True]
b=a[1:3:2]
c=a[0:1:1][0]
print(b)
print(c)
输出结果           

    - for循环

a=["dadgjgj",32465465,"王老五",True]
for b in a:
    print(b)
输出结果          

  5.元组(tuple):

  - 属于不可变类型  ,所以不能删除和修改 .  a=("dada",42432,True,"王老五")

  - 元组最后一定要加逗号, 否则可能会被认为是数字 , 避免出现错误

a=(1)
b=(1,)
c=(1,2,3,)
d=(1,2,3)
print(a,type(a))
print(b,type(b))
print(c,type(c))
print(d,type(d))
输出结果       

 

  1.元组的方法(无)

  2.元组公共方法

    - 计算长度:len

a=("dadgjgj",32465465,"王老五",True)
b=len(a)
print(b)
输出结果            

    - 索引

a=("dadgjgj",32465465,"王老五",True)
b=a[2]
print(b)
输出结果            

    - 切片

a=("dadgjgj",32465465,"王老五",True)
b=a[1:3]
print(b)
输出结果           

    - 步长

a=("dadgjgj",32465465,"王老五",True)
b=a[0:3:2]
print(b)
输出结果          

    - for循环

a=("dadgjgj",32465465,"王老五",True)
for b in a :
    print(b)
输出结果           

 

 6.字典(dict) : 可变类型

  1.字典的写法 : a={"name":"王老五","age":"38","hobby":"小姐姐"}

  2.字典由许多个键值对组成 , 冒号前面的为键 , 冒号后面为值 . 

  3.键只能是不可变类型 , 所以不能是列表 , 字典和集合 ; 值可以任意取值 . 

 --字典的方法

   - keys  :  键

a={"name":"王老五","age":"38","hobby":"小姐姐"}
for b in a.keys():
    print(b)
输出结果           

    - values : 值

a={"name":"王老五","age":"38","hobby":"小姐姐"}
for b in a.values():
    print(b)
输出结果           

    - items : 键值对   :   用完后输出的是元组

a={"name":"王老五","age":"38","hobby":"小姐姐"}
for b in a.items():
    print(b)
输出结果             

    - get : 返回指定键的值

a={"name":"王老五","age":"38","hobby":"小姐姐"}
b=a.get("name")
print(b)
输出结果             

a={"name":"王老五","age":"38","hobby":"小姐姐"}
b=a.get("home") # 当输入内容不存在与字典时 , 显示None 表示空的,不存在的,无任何作用,专门用于提供空值
c=a.get("name")
print(b) # 直接用a.["home"]会显示报错
print(c)

输出结果  

    - update : 批量添加

a={"name":"王老五","age":"38","hobby":"小姐姐"}
a.update({"age":18})
print(a) # 如果添加的键存在则更新覆盖 , 如果不存在则增加 a.update({"烧饼":123,"home":"天津"}) print(a)
输出结果                 

    - pop

a={"name":"王老五","age":"38","hobby":"小姐姐"}
a.pop("name")
print(a)
输出结果              

  ---字典的公共方法

    - len

a={"name":"王老五","age":"38","hobby":"小姐姐"}
b=len(a)
print(b)          # 以键值对为单位算长度
输出结果              

 

    - 索引

a={"name":"王老五","age":"38","hobby":"小姐姐"}
b=a["name"]
print(b)           # 不再以索引位置找 , 按照键来找到值
输出结果              

 

    - del

a={"name":"王老五","age":"38","hobby":"小姐姐"}
del a["name"]      # 删除的都是整体 , 按一个键值对删除
print(a)  
输出结果              

 

    - 修改

a={"name":"王老五","age":"38","hobby":"小姐姐"}
a["智商"]="超级低"      # 没有的可以直接修改添加 , 如果要修改已有内容,只想修改键, 需要先整体删除,然后重新添加
print(a)               #  值可以直接修改
输出结果              
a={"name":"王老五","age":"38","hobby":"小姐姐"}
a["hobby"]="脑残"     #  值可以直接修改
 print(a) 
输出结果

      - for循环

   --- 字典使用  in或者not in 判断是否存在时, 默认判断键, 如果判断值, 需要使用循环或者强制转换成列表

a={"name":"王老五","age":"38","hobby":"小姐姐"}
if "王老五" in a:
    print("敏感字符")          # 默认判断键
else:
    print("正确")
输出结果           
# 判断值: 方式一
a={"name":"王老五","age":"38","hobby":"小姐姐"} b="王老五" message="正确" for m,n in a.items(): if a[m]==b: message="敏感字符" print(message)
输出结果
#  判断值: 方式二
a={"name":"王老五","age":"38","hobby":"小姐姐"} if '王老五' in list(a.values()): print("敏感") else: print("正确")
输出结果           
a={"name":"王老五","age":"38","hobby":"小姐姐"}
b={"k1":"v1"}
if a.get("k1")=="v1":
    print("包含")
else :
  print("zhengque")
输出结果            

 

  7.集合 (set) : 不重复,无序,可变类型

  - 集合的方法

    - add : 增加

a={"王老五","rwegd",45,45,"True",55}
a.add("大烧饼")      # 如果存在,不再添加,集合不重复
print(a)
输出结果        

    - discard : 删除

a={"王老五","rwegd",45,45,"True",55}
a.discard(45)
print(a)
输出结果       

    - update : 批量增加

a={"王老五","rwegd",45,45,"True",55}
a.update({"大烧饼","home",55})
print(a)                          # update增加的序列可以是列表 ,元组 ,集合
a.update(["不知道","在哪"])
print(a)
输出结果        

    - pop : 随机删除

  - 集合的公共方法

    - len

    - for循环 

  - 交集 : intersection

a={"王老五","rwegd",45,"True",55}
b={"王老五",468}
c=a.intersection(b)     # b可以是列表,元组和集合
print(c)
输出结果         

  - 并集 : union

  - 差集 : difference

a={"王老五","rwegd",45,"True",55}
b={"王老五",468}
c=a.difference(b)         # a不同于b的是什么,即a里面减去和b重复的那一部分
print(c)
输出结果          

  - 对称差集 : symmetric_difference

  - 嵌套 : 集合内不能是可变类型, 所以不能嵌套列表, 字典, 集合

  - hash : 集合和字典里面的键都会在内部进行一个hash算法, 并得到一个值, 用于快速找到 . 如果集合中有1和True或者0和False会认为是一样, 会显示1或0

info = {0, 2, 3, 4, False, "国风", None, (1, 2, 3)}#
print(info)
info = {
1:'alex',
True:'oldboy'
}
print(info)
输出结果          

 

 8.内存

  --主要区分是赋值操作还是进行了内部修改

  -- 查看内存地址 id

 

   == 和 is有什么区别?

  答 :== 用于比较值是否相等。

       is 用于比较内存地址是否

   

      注:  按理 v1 和 v2 应该是不同的内存地址。特殊
   以下在python中为了节省内存, 常用的在同一内存地址

  1. 整型: -5 ~ 256
  2. 字符串:"Alex"*1当大于1时开辟新地址

       

        

  9.深浅拷贝 

  - 写代码前  要写   import copy

  - 对于不可变类型 , 深拷贝和浅拷贝的内存地址是不变的 . 其中int , str , bool .    tuple是特殊的

  - 可变类型 : 浅拷贝copy.copy() : 只拷贝最外层 , 深拷贝copy.deepcopy() : 是拷贝所有(嵌套)可变类型 . 

a=[1,2,3,[4,5,6]]
import copy
b=copy.copy(a)
print(b,id(a),id(b))
print(b,id(a[3]),id(b[3]))
c=copy.deepcopy(a)
print(c,id(a),id(c))
print(c,id(a[3]),id(c[3]))
输出结果            

   - 对于元组(tuple) 如果不嵌套则 , 深浅拷贝id 不变 , 如果嵌套可变类型 , 则深拷贝会把元组重新拷贝一份 . 

 

 10.数据类型间的强制转换

  - int强制转换只能转换数字字符串

  - str 强制转换

    - str(整型)

    - str(布尔值)

    - 列表和元组不能直接转换 : 需要通过join连接,插入空字符串

a=["王老五","大烧饼","asdf"]
b=("王老五","大烧饼","asdf")     # 转换成字符串,元组和列表中元素必须是字符串才行
c="".join(a)
d="".join(b)
print(c)
print(d)
输出结果         

  - list(列表)强制转换

     - list (字符串)

     - list (元组)

b=("王老五","大烧饼","asdf")
m="qwert"
a=list(b)
n=list(m)
print(a)
print(n)
输出结果          

  - tuple (元组)强制转换

  - tuple (字符串)

  - tuple (列表)

a=["王老五","大烧饼","asdf"]
m="qwert"
b=tuple(a)
n=tuple(m)
print(b)
print(n)
输出结果       

5.变量

  1.数字,字母,下划线组成。

  2.不能以数字开头。

  3.不能使用python关键字。

  4.命名有意义,见名知意。

  5.多个单词组成名字用下划线连接。

6.注释

  - # 单行注释

  - """    """ 多行注释

7.运算符

  1.算数运算符

    

  2.比较运算符

        

  3.赋值运算符

              

  4.逻辑运算符

              

  5.成员运算符

    - in

    - not in

  6.运算符优先级

       

      not1>2and3or4<5or6and0<1       先算大于,小于,然后算not,之后算and,最后算or

 

8.字符串格式化

  - %s

  -%d   整型

  -%%(以双百分号代%)

  - 3.6新增 : 

name="liuweida"
print(f"{name}最帅")
输出结果           

 

9.条件判断

  - if / elif / else

10.循环语句

  - while

  - while else :当while循环结束后才执行,使用语句结束,不执行

  - for 。。 in 。。

  - break :结束当前循环

  - continue:结束本次循环,本次循环后面程序不执行

11.其他

  - markdown笔记

  - git本地:

  - git软件

【常用命令】

  - git status

  - git add .

  - git commit -m ''提交记录'

  - git push origin master

  - 远程:码云 / github(程序员交友平台)

面试相关:

  1. 写出你常用的git命令。

  2. 你们公司是怎么用git做开发的?

    1. 在码云或GitHub等代码托管的网站创建自己仓库,创建完之后码云会给我一个仓库地址,如:https://gitee.com/old_boy_python_stack_21/190326032.git

    2. 自己写代码.....

    3. 将代码提交到远程 仓库。  

    - 初始化进入一个任意文件夹,如:D:\homework\    

      git init

      git config 邮箱

      git config 姓名

      git remote add origin https://gitee.com/old_boy_python_stack_21/190326032.git

      注意:至此git已经将 D:\homework\目录管理起来,以后此文件夹有任何变化,git都会检测到(使用 git status 命令可以查看状态)

    - 代码收集并提交

      git status

      git add .

      git commit -m ''记录"

      git push origin master 将本地D:\homework\目录下的内容同步到 码云仓库。

    - 修改代码或删除文件等对本地 D:\homework\ 下任何文件做操作。

      git statusgit add .git commit -m ''记录"

      git push origin master 将本地D:\homework\目录下的内容同步到 码云仓库。

    【避免】如果远程有本地没有的代码,必须先执行:【可能引发合并问题】  

      git pull origin master

      git status

      git add .

      git commit -m ''记录"

      git push origin master 将本地D:\homework\目录下的内容同步到 码云仓库。

 


原文链接:https://www.cnblogs.com/liuweida/p/10649538.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:大话算法-排序-堆排序

下一篇:oldboy s21day06