美文网首页Python学习
Python学习笔记-第2天: 开发环境和语法基础(1)

Python学习笔记-第2天: 开发环境和语法基础(1)

作者: 6d1bf2ffc4f3 | 来源:发表于2019-12-04 18:02 被阅读0次

    第二天 开发环境和语法基础(1)

    今天主要计划学习用VSCode搭建开发环境及Python语法基础
    学习涉及到的源码地址:GitHub源码

    使用VSCode打造Python开发环境

    可以用来开发Python的开发工具很多,我选择了VSCode,原因很简单,因为它是跨平台的,而且免费的。

    • 下载安装VS Code

      从VSCode官方网站下载自己喜欢的工作环境的版本进行安装,很简单在这里就不多说了。

    • 安装Python环境

      Python官网下载适合自己开发环境的Python3.x版本进行安装.

    • 配置VSCode开发Python

      在VSCode中搜索扩展插件:Python,安装后,重新加载。就可以愉快的撸代码了。Python插件自带的Pylint功能会在你输入的过程中给你自动提示,自动完成,以及错误提示。这里需要提醒各位,VSCode包括VS中,Tab都默认是4个空格。

    • VSCode常用的几个操作快捷键:

      首先是F1/Ctrl+Shit+P万能键,谁用谁知道
      Ctrl+P:文件切换
      Ctrl+空格:自动提示
      F12/Ctrl+左键:跳转到定义
      Shift+F12:预览定义
      Ctrl+G:跳转行号
      Ctrl+/:注释切换
      Alt+↑↓:整行上下移动
      Ctrl+↑↓:编辑器垂直滚动条上下移动,光标不动
      Ctrl+Backspace/Delete:整词/连续空白删除
      Ctrl+→←:光标整词移动
      Ctrl+F查找/Ctrl+Shift+F在文件中查找,这都属于通用的,类似的就不说了啊。
      
    • 调试配置

      随时随地,打开一个Pyhton源码文件,按F5,选择调试运行当前文件。项目中一般需要配置启动项目入口文件,传统意义上它叫:main.py.注意,VSCode默认在调试后,会停在第一句。

    调试快捷键:

    ```
    F5:调试/继续,
    F10:单步跳过,
    F11:单步进入,
    Shift+F11:跳出。
    F9:切换断点
    ```
    

    接下来,开撸吧。

    Python编程基础

    Python程序的基本格式

    • 记住Python使用缩进控制代码范围的

      这点有点像coffee script,应该是coffee学习python;区别于Java、C、C++等用{}控制代码块。“缩进”是Python语法强制的规定。缩进时,几个空格都是允许的,但是数目必须统一且前后一致。通常采用“四个空格”表示一个缩进。

    • 使用#进行行注释,用三个连续的'''进行块注释

    • 变量名是区分大小写的

    • 结尾不需要使用;进行结束

    • 使用\行连接比较长的行内容

    • 一段示例代码:

      '''
      这里是一大块注释语句
      为什么要使用块注释,哪里使用,我就不多说了
      程序员都懂的
      '''
      a = "a"
      A = "c" # a 和 A 是两个不同的变量
      #用\连接长字符串
      b = "I love google than \
          baidu,because of xxxxxx\
          nnnnnn\
          oooo"    
      if True: # 行注释 "True"是Python的一个Bool值
      #下面的行相对于if用Tab控制了缩进
          print("我是对的") #不需要使用;结束语句
          print("Hello")
      if False: #上一个代码块结束了,开始新的代码
          print("我错了吗")
          print("World")
      

    Python程序的构成

    • Python程序由模块组成的,通常就是一个py源文件
    • 模块由一系列的语句构成
    • 语句用于创建对象、变量赋值、调用函数、控制语句等

    ***重点Python中的对象

    在Python中一切都是对象。

    对象由三部分组成:identity,type,value组成,它的本质被解释器放在内存堆中。拥有特定的值,支持特定类型的相关操作。

    比如定义一个变量:a = 1

    1就是对象,它存在在内存中如下:

    id type value
    4395429648 int 1

    变量a其实是对象id的引用,存放在内存栈中;如果在定义一个变量:b = 1,那么a和b指向的是同一个引用地址。

    可以通过内置方法:id(a) 或 id(1)获取对象的id,type(a)获取对象的类型。

    ***重点: Python只会缓存[-5,无穷大]的整数,所以,在这里,a和b的引用地址一样。这里不注意的话,可能是个坑。内置数据类型:数值型,字符串,列表,字典等都会有自己的对象缓存池,这样做的好处是,避免了频繁的申请内存,释放内存,这样会极大的降低应用程序的运行速度,还会造成大量的内存碎片。因此提供对象缓存机制是非常重要的。

    综上,可以总结两个点:

    • python是动态语言

      定义变量不需要指定类型,解释器会根据其引用的对象自动确定其类型

    • python也是强类型语言

      因为对象是分了类型的,不同的类型支持的操作是不一样的

    Python的标识符

    • 关于命名就不多说了,规则和大多数开发语言一致
    • 重点说一下,尽量不要用__开头的标识符进行命名,因为双下划线开头和结尾的名称通常有特殊含义,如init,在python中表示类的构造函数

    变量的定义和赋值

    • 变量名 = 表达式

      python从右往左进行解释,先计算右边的表达式生成一个对象,然后将对象地址赋予对应的变量。

    • 变量的删除

      a = 1
      del(a)
      

      变量删除后,没有被引用的对象会被垃圾回收机制自动回收。

    • 链式赋值

      x = y = z = 1
      定义了x,y,z三个变量,且他们的值都是1.

    • 结构赋值

      x,y = 1,2

      相当于x=1,y=2

      一个技巧,通过这样的方式可以很容易实现变量的交换,如:

      x = 1
      y = 2
      x,y = y,x # 一句话就搞定,这就是Python的优势
      print(x,y) # 2,1
      
    • 常量

      这个。。。。Python中没有常量,切记,真的没有。可以在编码是约定一个变量为常量,如:CONST = 1,然后记住不要修改它哦

    内置数据类型和常用运算符号

    • 内置类型

      1、整型

      Python 中,除 10 进制,还有其他三种进制:

      0b或0B二进制: 0 1
      0o或0O八进制: 0 1 2 3 4 5 6 7
      0x或0X十六进制:0 1 2 3 4 5 6 7 8 9 a b c d e f
      

      ** 注意这个在Python中没有大小限制,无限大;所以科学计算还是Python好。

      int() 方法可以将浮点类型、布尔、符合要求的字符串转换成整数

      整数和浮点数混合运算时,表达式结果自动转型成浮点数。

      int(9.7) # 9直接去掉小数点后面的
      int("9") # 9
      int(True) # 1
      int(False) # 0
      int("3.14") # 报错
      int("abcef") # 报错
      
      3+7.0 # 10.0 自动转换
      

      四舍五入用round()函数

      2、浮点型

      两个表达方式:3.14 或 314e-2

      float() 可以进行强制转换

      3、布尔型

      两个值:True 和 False

      布尔值得本质是0和1,所以他们可以进行数学运算

      1 + True # 2
      1 + False # 1
      

      4、字符串

      双引号“”定义一个字符串

    • 数学运算符

      +,-,,/,//,%,*

      如:

      #  //是整除的运算
      a = 9//4 # 2
      # **是冥运算
      a = 2**10 # 1024
      

      被除数为0会报错,还是写一下吧。

    • 比较关系运算符

      > , >= , <, <=, ==, !=

      关系运算符是可以连用的,如:

      a = 3
      1 < a < 4 # True
      1 < a != 5 # True
      3 != a !=5 # False
      
    • 逻辑运算符

      and,or,not

    • 同一运算符

      is, is not

      同一运算符用于比较对象的地址。

      a = 1
      b = 1
      a is b # True
      
      c = 2
      a is not c # True
      

      is 与 == 区别:

      is 用于判断两个变量引用对象是否为同一个,既比较对象的地址。
      == 用于判断引用变量引用对象的值是否相等,默认调用对象的 eq()方法。

    • 按位运算符

    &与,|或,^异或,>>,<< 移位

    a = 0b1001
    b = 0b1000
    
    bin(a|b) # 0b1001 参加运算的两个对象只要有一个为1,其值为1
    bin(a&b) # 0b1000 两位同时为“1”,结果才为“1”,否则为0
    bin(a^b) # 0b1    参加运算的两个对象,如果两个相应位为“异”(值不同),则该位结果为1,否则为0。
    
    bin(a>>2) #0b10 右边移出的空位一律补0,丢弃移出的位
    bin(a<<2) #0b100100 左边移出的空位一律补0
    
    • 复合赋值运算符

      就是+=,*=,//=,|=等等

      a = 1
      a += 1 # 2   a = a + 1
      

      注意:Python没有++,--

    • 运算符优先级问题

      1. 乘除优先加减
      2. 位运算和算术运算 > 比较运算符 > 赋值运算符 > 逻辑运算符

    字符串

    Python字符串的特点

    • 不可变

      python中的字符串是不可变化,修改字符串实际是新建一个字符串对象,将新的对象地址赋值给引用它的对象。

      a = "abcdef"
      a[3] = "1" # 注意,这里会报错
      
    • 字符串是一个序列

      可以通过下标进行访问

      正向:最左侧第一个字符0开始直到len(str)-1为止

      反向:最右侧第一个字符-1开始倒数直到-len(str)为止。

    • 不支持单字符,单字符也是字符串

    • 直接支持Unicode编码

      在python3中,字符编码集是Unicode的,支持世界上任何语言集合,默认是16位,内置函数ord()可以把字符转换成对应的Unicode码;chr()可以把十进制数字转换成对应的字符。

      ord('A') # 65
      chr(65) # A
      
      ord('林') # 26519
      chr(26519) # 林
      

    使用',",''',"""创建字符串和转义符号\

    ''' 或 """ 可以创建多行字符串
    "   里面可以不用转义'
    \  用来转义特殊符号
    
    a = ''' 测试创建多行字符串:
    a = "abcd"
    b = "ooooo"
    完毕'''
    b = "双引号'可以不用转义'"
    c = '' # 控制符串
    d = '\'\'\'转义符号测试 \r\t\\\n完毕'
    
    e = "abcd"
    e[1] # b
    

    常用操作及内置函数

    • 字符串拼接符号: +
    • 字符串复制符号: *
    • in 或 not in 关键字,判断某个字符串)是否存在于指定字符串中。
    • is 或 is not 判断两个对象是否同一个对象
    • == 或 != 判断两个字符串值是否相等
    a = "a" + "b" # ab
    b = "a" * 3 # aaa
    
    c = "ab"
    c is a # True
    c is not a # False
    
    d = "abc#"
    e = "abc#"
    
    #### 此处需要注意,Python仅对字符串由_、字符、数字组成的字符串进行缓存(字符串驻留机制)
    d is e # False 
    d is not e # True
    
    d == e # True
    
    "a" in d # True
    
    "f" not in d # True
    
    a1 = "ab"
    a2 = "bc"
    
    a1 + a2 == "abbc" # True
    a1 + a2 is "abbc" # False
    
    
    内置函数
    • len() 获取字符串的长度
    • str() 将其他类型转换成字符串
    a = "abcdef"
    b = ""
    c = 314e-2
    
    len(a) # 6
    len(b) # 0
    
    str(c) # 3.14
    str(True) # 1
    
    成员函数
    • replace()字符串替换

      a = 'abcdef'
      b = a.replace("c","x")
      
      print(a) # abcdef 注意a并没改变
      print(b) # abxdef
      
      a = a.replace("c","x")
      print(a) # abxdef a引用地址重新指向
      
      
    • slice()切片操作提取子字符串

      语法:[起始start:终止end:步长step],不包含end位置的字符

      a = "0123456789"
      a[0:2] # 01
      a[:] # 0123456789 提取所有字符
      a[:2] # 01 默认start 0
      a[::2] # 02468 步长为2
      a[9:100] # 9 结束超过范围了,相当于直接到最后一个
      a[9:8] # '' 开始位置超过范围了,不报错返回空
      a[11:100] # '' 开始位置超过范围了,不报错返回空
      a[:2:-1] # 9876543 步长为负数时,start默认为-1
      a[:2:-2] # 9753
      
      a[-8:-2] # 234567 正向截取,从倒数第8个到倒数第2个(不含)
      a[-2:-1] # 8 正向截取,结束位置不对,只取开头的值
      
      print(a) # 0123456789 说明所有操作返回的是新对象地址
      
    • split()、join()分割和合并

      split()可以基于指定分隔符(字符串或正则表达式)将字符串分隔成子字符串列表,默认为空

      join()用于将字符串列表连接起来

      a = "a b c     d"
      a.split() # ['a', 'b', 'c', 'd'] 相当于用\s+分割
      b = ["a","b","c"]
      *.join(b) # a*b*c
      "".join(b) # abc 注意这个性能优于 + 连接字符
      
    • strip()去除字符串首尾指定信息

      默认去掉首尾的空格,可以指定去掉,如strip("##")

    • lstrip()去除字符串左边指定信息

    • rstrip()去除字符串右边指定信息

    • capitalize()、title()、upper()、lower()、swapcase()大小写转换

    • center()、ljust()、rjust()这三个函数用于对字符串实现排版

    • isalnum()是否为字母或数字

    • isalpha()检测字符串是否只由字母组成(含汉字)。

    • isdigit()检测字符串是否只由数字组成

    • isspace()检测是否为空白符

    • isupper()是否为大写字母

    • islower()是否为小写字母

    • startswith()、endswith()、find()、rfind()、count()字符串查找

    a = "abcdabcdabcdabcd"
    b = "abcdabcd测试abcdabcd"
    
    a.startswith("abcd") #True
    a.endswith("d") # True
    a.find("abcd") # 0 第一次出现位置
    a.rfind("abcd") # 14 最后一次出现的位置
    a.count("abcd") # 4出现4次
    
    a.capitalize() # Abcdabcdabcdabcd
    b.swapcase()  # ABCDABCD测试ABCDABCD
    
    b.center(30,'*') # ******abcdabcd测试abcdabcd****** 30为填充后的总长度
    
    • format() 格式化输出

      基本语法是通过 {索引/参数} 和 :

      a = "测试格式化:{0},{1},{0}"
      b = "测试格式化:{tag1},{tag2},{tag1}"
      a.format("占位0","占位1") # '测试格式化:占位0,占位1,占位0'
      b.format(tag1="占位0",tag2="占位1") # '测试格式化:占位0,占位1,占位0'
      
      c = "格式化:{0:*^10},{1:#>10},{0:<10}"
      c.format("占位0","占位1") # '格式化:***占位0****,#######占位1,占位0       '  注意最后的空格
      

      浮点数通过f,整数通过d进行需要的格式化。

      a = "我的身高是{0:d}cm,体重{1:.2f}kg"
      a.format(180,71.5489) # '我的身高是180cm,体重71.55kg' 注意有四舍五入
      '''
      数字         格式    输出          描述
      3.1415926   {:.2f}  3.14         保留小数点后两位
      3.1415926   {:+.2f} 3.14         带符号保留小数点后两位
      2.71828     {:.0f}  3            不带小数 
      5           {:0>2d} 05           数字补零 (填充左边, 宽度为 2)
      5           {:x<4d} 5xxx         数字补 x (填充右边, 宽度为 4)
      10          {:x<4d} 10xx         数字补 x (填充右边, 宽度为 4)
      1000000     {:,}    1,000,000    以逗号分隔的数字格式
      0.25        {:.2%}  25.00%       百分比格式 
      1000000000  {:.2e}  1.00E+09     指数记法
      13          {:10d}  13           右对齐 (默认, 宽度为 10)
      13          {:<10d} 13           左对齐 (宽度为 10)
      13          {:^10d} 13           中间对齐 (宽度为 10)
      '''
      

    Python中的序列

    序列是一种数据存储方式,用来存储一系列的数据。在内存中,序列就是一块用来存放多个值的连续的内存空间。Python中常用的序列结构有:字符串、列表、元组、字典、集合。

    列表

    列表是大小可变的、用于存储任意数目、任意类型的数据集合。

    • 创建列表

      1. 基本语法
      a = [] # 空列表
      b = [1, 2, 3,'abc', True]
      
      1. 通过list()创建

      将可迭代的对象转换成列表

      a = list() # 空列表
      b = list('abcd,efg') # ['a','b',....]
      c = list(range(10))
      
      1. 通过range()创建

        语法:range([start,] end [,step])

      2. 推导式生成列表

        可以非常方便的创建复杂的列表

        a = [x*2 for x in range(5)] # 循环创建多个元素
        b = [x*2 for x in range(100) if x%6==0] #通过 if 过滤元素
        
    • 列表元素的添加

      1. append()

        在列表尾部添加一个元素,原列表地址不变,这个性能没问题,推荐使用

      2. +运算符

        会产生新的对象,元素过大影响性能。

      3. extend()

        不会产生新的对象,在原对象尾部直接追加新的元素

      4. insert()

        插入元素到列表对象的任意制定位置。插入元素后面的元素会发生移动。对性能有影响。

      5. *复制扩展

      a = [1,2,3,4]
      a.append(5)
      print(a) # [1, 2, 3, 4, 5]
      id(a) # 4398822896
      a = a + [5,6]
      print(a) # [1, 2, 3, 4, 5, 5, 6]
      id(a) # 4398824096
      a.extend([7,8,9])
      print(a) # [1, 2, 3, 4, 5, 5, 6, 7, 8, 9]
      id(a) # 4398824096
      a.insert(4,100)
      print(a) # [1, 2, 3, 4, 100, 5, 5, 6, 7, 8, 9]
      id(a) # 4398824096
      a = a * 2
      print(a) #[1, 2, 3, 4, 100, 5, 5, 6, 7, 8, 9, 1, 2, 3, 4, 100, 5, 5, 6, 7, 8, 9]
      id(a) # 4398822896
      

      疑问: 这里最后的id和之前的一样了,属于什么情况呢,新分配了一个刚才使用过的地址?

    • 元素的删除

      1. del

        语法:del a[1],本质是数组的拷贝,将删除元素后面的元素地址一次向前拷贝。

      2. pop

        pop()删除并返回指定位置元素,如果未指定位置则默认操作列表最后一个元素。推荐使用默认操作,不影响性能。

      3. remove

        删除首次出现的指定元素,若不存在该元素抛出异常。

      a = [1,2,3,4,5]
      del a[1] 
      print(a) # [1, 3, 4, 5]
      a.pop() # 5
      print(a) # [1, 3, 4]
      a.remove(3)
      print(a) # [1, 4]
      
    • 列表基本操作

      1. 通过索引直接访问元素。索引的区间在[0, 列表长度-1]这个范围。超过索引会引发异常。

      2. index() 可以获取指定范围内元素首次匹配的索引

        语法: index(value,[start,[end]])

      3. count() 获得指定元素在列表中出现的次数

      4. len() 获取列表长度

      5. in 或 not in判定元素是否存在于列表

      6. 列表切片,和前面的字符串操作基本一致

      7. 列表的遍历

        语法:for item in listA:

      8. 列表复制: [] + listA,直接listA = listB 只是引用赋值

      9. max 和 min 返回列表中最大和最小值

      10. sum 对数值列表进行求和

      a = [1,2,3,4,5]
      b = [1,2,3,4,5]
      
      a == b # True
      a is b # False
      
      a[0] # 1
      a.index(2) # 1
      
      a.count(5) # 1 
      len(a) # 5
      5 in a # True
      a[::-1] # [5, 4, 3, 2, 1] 翻转列表元素
      
      c = [] + a
      c == b # True
      c is a # False
      
      d = a
      d is a # True
      
      for item in d:
          print(item) # 依次打印 1 2 3 4 5
      
      sum(d) # 15
      max(d) # 5
      min(d) # 1
      
      e = ['a','abc',1,True,0,False] # 不适用 max sum min 会报错
      
    • 列表排序

      1. 对象方法sort()在原列表中进行排序

      2. 对象方法reverse()翻转原列表

      3. 内置函数sorted()返回排序后的新列表,原列表不变

      4. 内置函数reversed()返回翻转数据后的迭代器对象,原列表不变

        注意这里返回的的是迭代器,需要用list()生成列表,迭代器只能用一次

    ```python
    a = [1,2,3,4,5]
    b = ['a','b','c','d']
    c = ['a','abc','1',2,True]
    
    a.sort() 
    print(a) # [1,2,3,4,5]
    b.sort(reverse=True) #
    print(b) # ['d', 'c', 'b', 'a']
    
    c.sort() # 报错:not supported between instances of 'int' and 'str'
    
    a.reverse()
    print(a) # [5, 4, 3, 2, 1]
    
    a1 = sorted(a)
    print(a) # [5, 4, 3, 2, 1]
    print(a1) # [1, 2, 3, 4, 5]
    
    ```
    
    • 二纬和多维列表

      可以任意嵌套多维列表

      a = [
          [1,2,3,4],
          5,
          ['a','b','c',[10,20,30]],
          'abcd'
      ]
      '''
      这样的列表需要一些技巧才能进行遍历
      '''
      
      • 思考

        Python的列表和Javascipt的数组很像,都是动态的,可以随时中增加的,对其中元素类型不做任何限制的。对处理复杂的数据结构,提供了相当的方便。

    相关文章

      网友评论

        本文标题:Python学习笔记-第2天: 开发环境和语法基础(1)

        本文链接:https://www.haomeiwen.com/subject/oyilgctx.html