前言

第一个程序.py

1	print("hello python")

基本语法

type(a) = 数据类型

整数（在线进制转换）
- 定义 a = 12
- Python可以处理任意大小的整数，包括负数
- 支持二进制、八进制、十进制、十六进制
  | 进制 | 前缀 | 举例 | 结果 |
  | :—: | :———: | :————: | :—: |
  | 2 | 0b或者0B | a = 0b1010 | 10 |
  | 8 | 0o或者0O | a = 0o12 | 10 |
  | 10 | 无 | a = 10 | 10 |
  | 16 | 0x或者0X | a = 0xa | 10 |
浮点数
- 定义
  a = 1.2
  b = .4 （b = 0.4 ）
  c = 1.2e-4 （科学计数法 e+4 表示10的4次方相反则是-方）
运算
- 整数除法以及浮点数运算结果返回值为浮点数
- 整数加减乘运算，返回值为整数
  | 类型 | 运算 | 返回值 |
  | ——— | ———— | ——— |
  | 整数 | + - * | 整数型 |
  | 整数 | / | 浮点型 |
  | 浮点数 | + - * / | 浮点型 |
不同除法的返回值
| 除号 | 返回值 |
| :—: | :————————-: |
| / | 返回值为float浮点数 |
| // | 返回值为int型整数 |

字符串

定义
a = test’’
a = “中文”
a = ‘’’ 双引号”1” 和单引号’2’用三引号’’’
转义符号：在Python中，以\”\“为转义符号
索引
a = ‘123456’
a[0] → 1
a[1] → 2
字符串内的元素不可以赋值
运算（有+无-，有*无/）
| 值 | 值 | 运算 | 结果 |
| :———-: | :———-: | :———-: | :—————: |
| a = “123” | b = “456” | c = a + b | c = “123456” |
| a = “123” | | c = a * 2 | c = “123123” |

格式化 .format用法

name = 'python'
age = 32
# 打印“我是Python，今年32岁了”
str_1 = "我是" + name + "," + "今年" + "32" + "岁了"
print(str_1)
# python2 常用
str_2 = "我是%s，今年%d岁了" % (name, age)
print(str_2)

str_3 = "我是{}，今年{}岁了" .format(name,age)
print(str_3)

str_4 = "我是{name}，今年{age}岁了".format(
    name = 'python',
    age = '32'
)
print(str_4)
# python 3.6+
str_5 = f"我是{name}，今年{age}岁了"
print(str_5)

布尔型
- Bool
  - 真 or 假
  - True or False
  - type(a) = ‘bool’
- NONE 空值
  - 空值为无值 a = None
  - a = “” a = 0 均非空值
    列表
列表
- 定义
  a = [1,2,3,4]
  b = [1,’abc’,2.0,[‘a’,’b’,’c’]]
- 列表可以包含：整数型、浮点型、字符串以及列表
- 列表解释
  默认起始位置为0位，从左向右为正值，反之则为负值
- 访问
  a[0] → 1
  a[0:1] → 1

切片

列表、字符串、元组均可
[a:]返回值
返回值：从起始位置a后的所有位
[a:b] 返回值
a：起始位置
b：末端位置
返回值：从起始位置a开始取b-a位
负向运算[a:-b]
返回值：从起始位置a到-b前（从a开始，去掉倒数b位后的全部）

```python
s = ‘abcdefg’
d = s[1:3] # 返回值取从列表s第一位开始，取3-1位
print(d)
s = ‘abcdefg’

取反向 - 值

print(s[1:3])
print(s[1:-2])

    
    |               | 取值    | 返回值 |
    | ------------- | ------- | ------ |
    | a = 'abcdefg' | a[1:3]  | bc     |
    | a = 'abcdefg' | a[1:-3] | bcd    |

3. 列表的基本操作
  
  - 长度： len(list)
  - 最大值： max(list)
  - 最小值： min(list)
  - 重复值： list.count(重复字符)
  - 末尾添加新元素：list.append()
  - 插入元素: list.insert(1,'b')*(位置，内容)*
  - 删除元素：list.remove()
  - 更新元素：list[1] = '赋值'
  - 翻转列表：list.reverse()
  - 列表排序：list.sort
  
  ```python
  # 获取列表的基本信息
  list1 = [9,1,-4,3,7,11,3]
  # 取列表的长度（元素个数）
  a = len(list1)
  print('list1的长度 =',a)
  # 取列表最大值
  big = max(list1)
  print('list1的最大值=',big)
  # 取列表最小值
  min = min(list1)
  print('list1的最小值=',min)
  # 取列表重复值
  count_3 =list1.count(3)
  print("list1的重复值=",count_3)
  print('list1的重复值3，重复次数为：{}'.format(list1.count(3)))
  # 列表改变
  list2 = ['a','c','d']
  # 给列表结尾添加新元素
  list2.append('e')
  print(list2)
  # 在列表元素之间插入新元素
  list2.insert(1,'b')
  print(list2)
  # 删除列表里面的元素
  list2.remove('b')
  print(list2)
  # 更新列表,取列表内元素赋值
  list2[0] = 1
  print(list2)
  # 列表翻转 123 → 321
  list3 = ['1','2','3']
  list3.reverse()
  print(list3)
  # 列表排序
  list4 = ['3','1','2']
  # 正序排序
  list4.sort()
  print(list4)
  # 倒序排序
  list4.sort(reverse=True)
  print(list4)

元组

创建与访问
- 创建
  a = (1, 2, 3, 4)
  b = 1, 2,
- 访问
  print(‘a[1]’)
  print(a[0:1])
  print(a[-1])

元组的基本操作

长度： len(tuple)
最大值： max(tuple)
最小值： min(tuple)
重复值：tuple.count(重复字符)
index：tuple.index()

# 获取元组基本信息
tuple = (9,1,-4,3,7,11,3)
# 取元组长度
lenth = len(tuple)
print('tuple的长度=',lenth)
# 取最大值
max = max(tuple)
print('tuple的最大值=',max)
# 取最小值
min = min(tuple)
print('tuple的最小值=',min)
# 取重复值
count3 = tuple.count(3)
print(count3)
print('元组中重复值3，重复的次数为：{}'.format(tuple.count(3)),'次')
# 取index
tuple.index(7)
print('tuple中7在第',tuple.index(7),'位')

列表与元组对比

元组是不可变的（Immutable）Python对象，储存在一块固定的内存里。
列表是可变的（mutable）Python对象，需要两块存储空间，一块固定的用于存放实际的列表数据，一块可变得空间用于拓展。

元组的创建与访问要比列表快，列表比元组操作更灵活（支持扩展：删除、添加、排序等操作）

功能对比
| | 列表 | 元组 |
| :——-: | :—: | :—: |
| max | ✓ | ✓ |
| min | ✓ | ✓ |
| len | ✓ | ✓ |
| count | ✓ | ✓ |
| append | ✓ | |
| insert | ✓ | |
| remove | ✓ | |
| reverse | ✓ | |
| sort | ✓ | |
| index | | ✓ |
| 赋值 | ✓ | |
综合比较
元组适用于固定性且不轻易改变的数据，访问速度快，安全性高。
列表适用于灵活性较强的数据，便于数据扩展操作。

字典

key 与 value
- key
  不可改变的数据类型可以作为键值对的键 key
  通常：int整数型、元组、字符串（列表不可以）
- value
  可以说任意数据

创建字典

a = {1:4,2:’a’,’3’:’c’}

tuple = (1, 2, 3)
c = ['a','b','c'] # 列表
d = (1, 2, 3) # 元组
h = {d:c} # 字典
print(h)

初始化
d = dict()
e = dict(a=’1’,b=’2’,c=’3’)
字典访问
dict[‘a’] 返回值：字典dict中key值为a的value返回值。
e = dict(a=’1’,b=’2’,c=’3’)
print(e[‘c’])
基本操作
- 改变值
  a = dict(a=’1’,b=’2’,c=’3’)
  返回值：{‘a’: ‘1’, ‘b’: ‘2’, ‘c’: ‘3’}
  a[‘c’] = 1
  返回值：{‘a’: ‘1’, ‘b’: ‘2’, ‘c’: ‘1’}
一个字典不可以成为另外一个字典的key值

集合

创建集合
a = {‘a’,’b’,’c’}
判断key值是否存在与字典中
t = ‘a’ in b # 判断key值a是否存在与字典b中，返回值：True or False
print(t)
列表转为集合并去除重复值
l = [1,2,3,4,5,5,5,6]
s = set(l)
print(s)
列表去除重复值
l2 = [1,1,2,2,3,3]
s2 = set(l2)
l2= list(s2)
print(l2)
print(list(set(l2)))
字符串转换为集合并去除重复，无序
a = ‘abcdefg’
s = set(a)
print(s) # 返回值： {‘b’, ‘a’, ‘f’, ‘e’, ‘d’, ‘g’, ‘c’}

```python
a = {

'a':1,
'b':2

}

创建集合 *集合，仅有key 无value

a = {‘a’,’b’,’c’}

b = {

'a':1,
'b':2,
'c':3

}

判断key值是否存在与字典中

t = ‘a’ in b # 判断key值a是否存在与字典b中，返回值：True or False
print(t)

列表转为集合并去除重复值

l = [1,2,3,4,5,5,5,6]
s = set(l)
print(s)

列表去除重复值

l2 = [1,1,2,2,3,3]
s2 = set(l2)
l2= list(s2)
print(l2)
print(list(set(l2)))

字符串转换为集合并去除重复，无序

a = ‘abcdefg’
s = set(a)
print(s) # 返回值： {‘b’, ‘a’, ‘f’, ‘e’, ‘d’, ‘g’, ‘c’}


7. 集合的基本操作

   - 创建集合
   - 添加元素
   - 删除元素
   - 集合运算-取交集
   - 集合运算-取并/全集
   - 集合运算-取并集并去除交集部分
   - a-b 去除集合a中与b交集的值

   ```python
   s = {1, 2, 3, 4, 5,}
   # 添加元素
   s.add(6)
   s.add(6) # 重复添加 覆盖
   print(s)
   # 删除元素
   s.remove(6)
   # s.remove(6) # 首次已经删除，次删除为空值，程序报错
   print(s)
   # 集合运算 交并补集
   s1 = {1, 2, 3, 4, 5}
   s2 = {5, 6, 7, 8, 9}
   # 取交集
   c = s1 & s2
   # 取并/全集
   c = s1 | s2
   # 取并集且去除交集值
   c = s1 ^ s2
   # a-b 去除集合a中与b交集的值
   c = s1 - s2

IF-条件语句

if 语句

1
2
3

a = int(input('请输入大于1的数字：'))
if a > 1 :
   print(a)

if … else 语句

a = int(input('请输入数字：'))
if a > 10 :
    print('数字比10大')
else:
    print('数字比10小')

if … elif … else 语句

a = int(input('请输入数字：'))
if a > 0 :
    print('结果为正值')
elif a == 0 :
    print('结果为0')
else:
    print('结果为负值')

实践

# 判断成绩
a = float(input('请输入你的成绩：'))
if a <= 60:
    print('完犊子吧')
elif a >= 60 and a < 70 :
    print('D')
elif a >= 70 and a < 80:
    print('C')
elif a >= 80 and a < 90:
    print('B')
elif a >= 90 and a <= 100:
    print('A')
elif a > 100 or a < 0:
    print('无效数据')

while循环

循环体

a = 10
while a > 0:
    print(a)
    a = a -1
print('结束')

注意判断语句，易造成死循环结构

实践

a = float(input('请输入既定目标：'))
b = float(input('请输入目标区间：'))
if a < 0 or a > 100 :
    print('既定目标取值范围为：0~100')
else:
    while a > 0:
        if a == 50:
            print('循环到达既定目标')
            break
        else:
            print(a)
            a = a - b
    print('结束')

瞎写的。。。。

猜数字

print("即将开始一个新的读书游戏，准备好了吗？回复：y/n")
a = input('')
b = 55
if a == 'y' :
    print('游戏规则:\n'
          '1. 随机输入一个数字，采取正确数字\n'
          '2. 你可以根据反馈的结果来更准确的接近正确答案\n')
    c =  float(input('现在你可以输入一个数字开始游戏了！\n'
                    '请输入：'))
    while c != b:
        if c > b:
            print('So Big !')
            c = float(input('请输入：'))
        elif c < b:
            print('SO Small !')
            c = float(input('请输入：'))
    print('You are right !')
elif a == 'n' :
    print('Ok！,Start when youre ready')

for-循环

字符串

1
2
3

a = '123456'
for a in a:
    print('字符串：'+ a)

列表

1
2
3

b = [1,2,3,4,5,6] # 列表 返回值int类型
for b in b:
    print("列表：" + str(b)) #str转化为类型

扩展

1
2
3

name = ['a','b','c','d']
for suoyin,zhi in enumerate(name):
    print('所引位置：[{}] ~ 值：{}'.format(suoyin,zhi))

元组

1
2
3

c = ('a','b','c','d') # 元组
for c in c :
    print('元组：'+ c)

字典

d = {
    1:'a',
    2:'b',
    3:'c'
}
for a,b in d.items(): # 返回key-value键值对
    print('key值：{} = value值： {}'.format(a,b))

集合

1
2
3

e = {1,2,3,4,5,6}
for i in e:
    print(e)

range (a,b,c)
- a : 起始
- b : 终止
- c : 步长
1
2
for x in range(1,10,2):
print(x)

break和continue

break

终止

for i in range(10):
    print(i)
    if i % 2  != 0:
        break

continue

结束或跳过本段命令，在循环体中结束本轮循环

for i in range(10):
    if i % 2 == 0:
        continue # 结束本次循环，进行下一轮循环
        print('d')
    print(i)

实例

import random
a = random.randint(1,100)
while True :
    num = float(input('请输入：'))
    if num == a :
        print('Your right！{}'.format(a))
        break
    elif num < a :
        print("Small!")
    elif num > a :
        print("Big!")

函数的定义和调用

定义
定义函数

函数体
函数的参数
实例