第二天 开发环境和语法基础（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]
  

  2. 通过list()创建

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

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

  3. 通过range()创建

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

  4. 推导式生成列表

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

     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的数组很像，都是动态的，可以随时中增加的，对其中元素类型不做任何限制的。对处理复杂的数据结构，提供了相当的方便。