第二天开发环境和语法基础（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中常用的序列结构有:字符串、列表、元组、字典、集合。

列表

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

创建列表

基本语法

a = [] # 空列表
b = [1, 2, 3,'abc', True]

通过list()创建

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

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

通过range()创建

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

推导式生成列表

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

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）

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

第二天开发环境和语法基础（1）

使用VSCode打造Python开发环境

Python编程基础

Python程序的基本格式

Python程序的构成

***重点Python中的对象

Python的标识符

变量的定义和赋值

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

字符串

Python字符串的特点

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

常用操作及内置函数

内置函数

成员函数

Python中的序列

列表

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

第二天 开发环境和语法基础（1）

使用VSCode打造Python开发环境

Python编程基础

Python程序的基本格式

Python程序的构成

***重点Python中的对象

Python的标识符

变量的定义和赋值

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

字符串

Python字符串的特点

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

常用操作及内置函数

内置函数

成员函数

Python中的序列

列表

第二天开发环境和语法基础（1）