# 基础语法



## 变量 & 语句

### 变量命名规则

* 英文大小写字母、数字、下划线组成
* 不能以数字开头
*   不能是关键字、保留字

    > 变量名称区分大小写

### 语句

```python
varname = value                   # 赋值语句
print(value,value2,value3...)     # 打印语句
varname = input('prompt')         # 控制台输入语句
```

## 数据类型

### 数值类型

> 整型、浮点型、字符串型、布尔型

### 字符串

> 用单引号、双引号、三个(单|双)引号引起来的一堆字符

### 布尔类型

> 表示真和假； 真：True 假：False

### 类型转换

```python
整型  =>  浮点     float(1)  ==> 1.0
整型  =>  字符     str(1)    ==> "1"
整型  =>  布尔     bool(1)   ==> True  非 0 为True， 0 为False
浮点  =>  整型     int(1.0)  ==> 1
浮点  =>  字符     str(1.0)  ==> '1.0'
浮点  =>  布尔     bool(1.0) ==> True  非 0 为True， 0 为False
布尔  =>  整型     int(True) ==> 1     int(False)==> 0 
布尔  =>  字符     str(True) ==> "True"  str(False) ==> "False"
布尔  =>  浮点     float(True)==> 1.0  float(False)==> 0.0
字符  =>  整型     int('1')   ==> 1    只能为数字，否则错误： ValueError
字符  =>  浮点     float('1') ==> 1.0  只能为数字，否则错误： ValueError
字符  =>  布尔     bool('1')  ==> True
```

### 运算

#### 四则运算

**数值**

> \+ - \* / % \*\* // 其中 / 和 // 被除数不能为0

**字符串**

* \+ 左右操作必须为字符串：　　 'abc' + 'def' = 'abcdef' '1' + '1' = '11'
* \* 其中一个为字符串，另一个为整数 '1' \* 2 = '12'

**bool**

> 需转换成 int 进行四则运算

#### 布尔运算

* 与 ==> and 含义： 只有两个为 **True** 结果为 **True**
* 或 ==> or 含义： 只要一个为**True** 结果为**True**
* 非 ==> not 含义：你真我假，你假我真

#### 关系运算

> \> 、< 、>=、<=、==、!=

### 控制语句

#### 条件

```python
if cond_1:
    code_1
elif cond_2:
    code_2
....
elif cond_n:
    code_n
...
else:
    else_code
# 结果
    1,2,3=>False, 4=> True
        code_4
    1,3=>False, 2, 4=>True
        code_2
    1,2, n=>False
        else_code
```

#### 循环

```python
while cond:
    while_code
# 语句控制
break     跳出循环
continue  跳过本次循环，下次继续
```

***

## 序列

### 列表

#### 类型名

> list

#### 语法

```python
nums = [1,2,3,4]
```

#### 操作

```python
# 元素的访问
    1. 从左到右 或者 从右到左
    2.  varname[idx]
varname[idx] = value     # 元素的修改
del varname[idx]         # 元素的删除
value in varname         # 元素是否再元素中
for value in varname     # 遍历元素
max(varname)             # 获取最大元素
min(varname)             # 获取最小元素
len(varname)             # 获取长度
```

#### 运算

```python
# 加 ===> 左操作数，右操作数都为列表
>>> [1,2] + [3,4]
[1, 2, 3, 4]

# 乘 ===> 左操作数和右操作数一个为整数一个为列表
>>> [1,2] * 3
[1, 2, 1, 2, 1, 2]
```

#### range

```python
range(start, end, step)         # 语法；由所有元素start + n * step组成的一个可遍历的数据结构。

>>> range(1,10,2)               # 从开始到结尾，步长为2，得到列表组合
[1, 3, 5, 7, 9]

>>> range(1,10)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
```

#### 类型转换

```python
list(varname)       # varname需要是可遍历的
>>> list([1,2,3])
[1, 2, 3]
```

#### 切片

```python
# 例如： varname = [1,2,3,4,5,6,7]
varname[start:end:step]                     # 由varname中索引为start+n*step对应的元素组成的列表 n自然数 [start, end]
varname[start:end]                          # 获取 `开始` 到 `结尾` 之间的数据
varname[:end]                               # 获取以 end 索引结束，前面所有的数据
varname[:]       > [1, 2, 3, 4, 5, 6, 7]    # 省略全部，代表截取全部内容，可以用来将一个列表拷给另一个列表
varname[:2]      > [1, 2]                   # 省略起始位置的索引，以及步长。默认起始位置从头开始，默认步长为1，结束位置索引为2
varname[::2]     > [1, 3, 5, 7]             # 省略起始位置的索引,步长为2,结束位为默认到结尾
varname[1::2]    > [2, 4, 6]                # 索引起始1，步长为2，结束位默认到结尾
varname[::-1]    > [7, 6, 5, 4, 3, 2, 1]    # 反向排序
varname[::-2]    > [7, 5, 3, 1]             # 反向排序，步长为2,结束位默认到结尾
varname[5:0:-1]  > [6, 5, 4, 3, 2]          # 反向排序，取值0~5的索引
varname[-2::-2]  > [6, 4, 2]                # 反向排序，步长为2,开始位置以结尾第2个索引开始，结束为开头位置
varname[0:-1:1]  > [1, 2, 3, 4, 5, 6]       # 从位置0开始到结束，每次增加1，截取。不包含结束索引位置
varname[0:7:3]   > [1, 4, 7]                # 从第一个位置到第7个位置，每3个取一个值

     
# 赋值
   varname[start:end] = []
```

#### 函数

> 帮助查询： dir || help

```python
List = [1,2]
# append  
    >>> List.append(3)       ===> 追加到列表尾部   ===> [1,2,3]
# clear    不支持python2
    >>> List.clear()         ===> 清空列表        ===> []
# copy
    >>> List2 = var.copy()   ===> 复制列表        ===> List2 = [1,2]
# count
    >>> List.count(2)        ===> 返回列表中数字 2 出现的次数，如果没有数据，则返回0  ===> 1
# extend
    >>> List.extend([3,4])   ===> 合并列表，添加到var末尾  ===> [1,2,3,4]
# index
    >>> List.index(1)        ===> 获取数据在列表中的索引位置 ====> 0
# insert
    >>> List.insert(100,4)  ===> 索引100处插入一个元素4   ===> [1,2,4]
# pop
    >>> List.pop(1)         ===> 弹出索引位置元素,通过索引删除该元素并返回，如果不指定则删除最后一个 ===> [1]
# remove
    >>> List.remove(1)      ===> 通过索引删除该元素并返回  ===> [1]
# reverse
    >>> List.reverse()      ===> 反转列表中的所有元素位置  ===> [2,1]
# sort
    >>> List.sort()         ===> 将列表进行重新排序,升序排列   ===> [1,2]
    >>> List.sort(reverse=True) ===> 倒序排列    ===> [2,1]
```

### 元组

```python
语法
    nums =(1, 2, 3, 4, [])
    一个元素时，最后的逗号不能省略
    
不可变
    不可变的列表
        索引对应的值/指向(数据结构)不可变
    tuple[index] = value
        报错
    tuple[index].append(value)
        不报错
```

### 字典

#### 基本用法

```python
DICT = {'语文': 89, '数学': 93, '英语': 5.7}

DICT['语文']                   # 通过 key 访问 value 。
DICT['物理'] = 90              # 通过 key 添加 key-value 对，如果已存在，就修改key-value对
del DICT['物理']               # 通过 key 删除 key-value 对。
'语文' in DICT                 # 通过 key 判断指定 key-value 对是否存在。
```

#### 常用方法

```python
DICT = {'语文': 89, '数学': 93, '英语': 5.7}
# 查看字典中包含那些方法： dir(dict)
max()       => 获取成绩最高的科目                                  ===> v,k = max(zip(DICT.values(),DICT.keys()))
min()       => 获取成绩最低的科目                                  ===> v,k = min(zip(DICT.values(),DICT.keys()))
len()       => 获取字典长度                                       ===> len(DICT)
clear()     => 清空字典                                           ===> DICT.clear()      ===> {}
copy()      => 复制字典                                           ===> DICT2=DICT.copy()
fromkeys()  => 给多个 key 创建字典，默认 None,也可传入一个默认value  ===> dict.fromkeys((13, 17), 'good')  ===> {13: 'good', 17: 'good'}
get()       => 通过key 来获取 value                               ===> DICT.get('语文')  ===> 89
pop()       => 获取指定 key 对应的 value，并删除这个 key-value      ===> DICT.pop('语文')  ===> {'数学': 93, '英语': 5.7}

update()    => 更新己有的字典,如果存在，覆盖，反之添加                ===> DICT.update({'物理':4.5})

items()     => 获取所有 key-value  => DICT.items()  ===> 返回 dict_items 对象 ===> list() 函数把对象转换成列表
            >>> list(DICT.items())   >>> [('语文', 89), ('数学', 93), ('英语', 5.7)]
             
keys()      => 获取所有 key  ===> DICT.keys()  => 返回 dict_keys 对象 ===> list() 函数把对象转换成列表
            >>> list(DICT.keys())     >>> ['语文', '数学', '英语']

values()    => 获取所有 value  ===> DICT.values()  => 返回 dict_values 对象 ===> list() 函数把对象转换成列表
            >>> list(DICT.values())     >>> [89, 93, 5.7]
    
popitem()   => 删除字典最后一个 key-value
            >>> DICT.popitem()     # 删除返回元组，可通过　　k,v = DICT.popitem() 方式赋值获取 key 和 value 值
            ('英语', 5.7)
            >>> DICT
            {'语文': 89, '数学': 93}

setdefault()=> 先判断是否存在key,如果不存在，就设置默认的 key-value值
            >>> DICT.setdefault('语文',80)
            89                              # 如果存在，就返回字典中值
            >>> DICT.setdefault('物理',80)
            80                              # 如果不存在，就返回给设定的值
            >>> DICT
            {'语文': 89, '数学': 93, '英语': 5.7, '物理': 80}
```

#### 遍历四法

> var = {'a': '1', 'b': '2', 'c': '3'}

```python
# 根据 key 值遍历
for key in var.keys():
    print(key+':'+var[key])
    
# 根据 value 遍历， 只输出 value 值
for value in var.values():
    print(value)
    
# 根据字典项遍历，输出每个字典项的元组
for kv in var.items():
    print(kv)         
    
# 根据字典键值对遍历
for key,value in var.items():
    print(key+':'+value)
```

### 字符串

```python
特殊字符
        \  ===> 转义
        \n ===> 换行
        \r ===> 回车
        \t ===> tab键
        \f ===> 换页
```

#### 遍历字符

```python
strs = 'abcdefg'
for s in strs: 
    print(s)
```

#### 基操

```python
strs = 'abcdefg'
max()      ===> 最大值    ===>　max(strs)　===> 'g'
min()      ===> 最小值    ===>　min(strs)  ===> 'a'
len()      ===> 长度      ===>  len(strs)  ===> 7
```

```python
count()              ===> 计算字符串中出现子字符串的次数                       ===> str.count('str')
index()              ===> 计算字符串中出现子字符串位置索引，若不存在则报错       ===> str.index('str')
find()               ===> 计算字符串中出现子字符串位置索引，若不存在则返回-1     ===> str.find('str')
startswith/endswith  ===> 判断字符串是否以参数开头/结尾, 返回 True or False    ===> str.startwith('str') or str.endswith('str')
format               ===> 格式化字符串                                       ===> 'My name is {}'.format('Tom')
lower/upper          ===> 将字符串转成小写/大写                               ===> str.lower() 【小写】  or  str.upper() 【大写】
replace              ===> 替换字符串                                         ===> str.replace('source','dest')
join                 ===> 使用字符串连接序列                                  ===> li = [1,2]  ===> ':'.join(li)   ===> 1:2
split/splitlines     ===> 分隔字符串为list                                   ===> strs = 1:2  ===> strs.split(':') ===> [1,2]
strip                ===> 去除字符串前后的空字符                              ===> strs = " abc 123 " ===> strs.strip()


# 假如 s 为字符串, 判断结果为   True or  False 
s.isalnum() 所有字符都是数字或者字母
s.isalpha() 所有字符都是字母
s.isdigit() 所有字符都是数字
s.islower() 所有字符都是小写
s.isupper() 所有字符都是大写
s.istitle() 所有单词都是首字母大写，像标题
s.isspace() 所有字符都是空白字符、\t、\n、
```

### 集合

> 定义： 没有重复不可变的元素的无序的list 由字典的key组成的一种数据结构 由{}包含，每个元素用逗号分割，元素不可变set() 特性： 无序、元素不重复、可遍历

#### 运算

```python
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 集合a中包含而集合b中不包含的元素     差集
{'r', 'd', 'b'}
>>> a | b                              # 集合a或b中包含的所有元素            并集
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 集合a和b中都包含了的元素            交集
{'a', 'c'}
>>> a ^ b                              # 不同时包含于a和b的元素              对差集
{'r', 'd', 'b', 'm', 'z', 'l'}

min、max、sum、len、in
>>> min(a)、max(a)、sum(a)、len(a)、'a' in a
```

#### 方法

```python
# add  添加元素： 参数可以是列表，元组，字典等
>>> thisset = set(("Google", "Runoob", "Taobao"))
>>> thisset.update({1,3})
>>> thisset.update([1,4],[5,6])
>>> thisset.add("Facebook")
>>> print(thisset)
{1, 3, 4, 5, 6, 'Taobao', 'Runoob', 'Facebook', 'Google'}

# remove 删除元素
>>> thisset.remove(1)
>>> print(thisset)
{3, 4, 5, 6, 'Taobao', 'Runoob', 'Facebook', 'Google'}
```

#### 用途

> 主要用在元素去重
