[Python知识库]Python编程基础（一）

Python编程基础（一）

打卡第一天啦！！！

认识Python

1. 面向对象 解释型计算机程序设计语言 胶水语言

变量和数据类型

变量

1. 程序中用变量存储数据
2. 变量的定义：变量名=数据
3. 变量使用：通过变量名来使用变量

a=10
print(a) #10
a='潘小雷'
print(a) #潘小雷

5. 首先定义变量，才能使用变量
6. 赋值变量时不需要指定数据类型，给这个变量赋值什么数据类型，这个变量就是什么类型

数据类型

数字（num）

1. int（有符号整数）
2. long（长整型)
3. float（浮点型）
4. complex（复数）
5. 布尔值（bool）

a=10
print(type(a)) #<class 'int'>
a=1.2
print(type(a)) #<class 'float'>
a=True
print(type(a)) #<class 'bool'>

字符串（str）

a='潘小雷'
print(type(a)) #<class 'str'>

字典（dict）

a={}
print(type(a)) #<class 'dict'>

元组（tuple）

a=()
print(type(a)) #<class 'tuple'>

列表（list）

a=[]
print(type(a)) #<class 'list'>

变量的命名规则

1. 变量必须以字母a到z、A到Z或下划线开头
2. 其他字符可以是字母、数字或_
3. 变量区分大小写
4. Python关键字不能用作变量名

Name='潘小雷'
print(Name) #潘小雷
name='雨宙'
print(name) #雨宙
_age=20
print(_age) #20

变量的命名规范

1. 见名知意，如password用作密码
2. 小驼峰式命名法：第一个单词首字母小写其他单词首字母大写，如userName
3. 大驼峰式命名法：全部单词首字母都大写，如UserName
4. 下划线命名法：每个单词用下划线连接，如user_name

算数和比较运算

算数运算

1. 加法、减法、乘法、除法、指数（**)、取余（%）、地板除（//）

a=7
b=3
print(a+b) #10
print(a-b) #4
print(a*b) #21
print(a/b) #2.3333333333333335
print(a%b) #1
print(a//b) #2

比较运算

1. 等于==
2. 不等于！=
3. 大于>
4. 小于<
5. 大于或等于>=
6. 小于或等于<=

a,b=10,5
print(a==b) #False
print(a!=b) #True
print(a>b) #True
print(a<b) #False
print(a>=b) #True
print(a<=b) #False

7. 结果是bool类型的数据

逻辑运算符

1. and条件比较严格，两边的结果都需要为True，结果为True，否则False

a,b,c,d=23,18,10,3
print(a+b>c and c<d) #False
print(a+b>c and c>d) #True

2. or条件有一个为真，结果就为真

a,b,c,d=23,18,10,3
print(a<b or b>d) #True
print(a<b or b<d) #False

3. not取反，真假切换

a,b,c,d=23,18,10,3
print(not a>b) #False

4. 优先级 （）-》not-》and-》or

赋值运算符

1. = 赋值运算符
2. += 加法赋值运算符
3. -= 减法赋值运算符
4. *= 乘法赋值运算符
5. /= 除法赋值运算符
6. %= 取模赋值运算符
7. **= 幂赋值运算符
8. //= 取整赋值运算符

a,b,c,d=23,18,10,3
a+=c
print(a) #33

Python输入和输出

Python输出

name='潘小雷'
age=20
print('我的名字是%s，我的年龄是%d'%(name,age)) 
# 我的名字是潘小雷，我的年龄是20

name='潘小雷'
age=20
print('我的名字是{}'.format(name)+'，我的年龄是{}'.format(age))
# 我的名字是潘小雷，我的年龄是20

name='潘小雷'
age=20
print('我的名字是{}，我的年龄是{}'.format(name,age))
# 我的名字是潘小雷，我的年龄是20

Python输入

name=input("请输入您的姓名：")
age=int(input("请输入您的年龄：")) #需要强制类型转换，否则为字符串类型
print('我的名字是{}，我的年龄是{}'.format(name,age))
# 请输入您的姓名：潘小雷
# 请输入您的年龄：20
# 我的名字是潘小雷，我的年龄是20

流程控制结构

1. 流程：计算机执行代码的顺序
2. 流程控制：对计算机代码执行的顺序进行有效的管理
3. 流程控制的分类：
   （1）顺序流程
   （2）选择流程/分支流程：单分支、双分支、多分支
   （3）循环流程

选择流程

1. 单分支

score=100
if score==100:
    print('满分啦')
    pass #空语句
print('语句运行结束')
# 满分啦
# 语句运行结束

2. 双分支

score=99
if score==100:
    print('满分啦')
    pass #空语句
else:
    print('没有满分')
    pass
print('语句运行结束')
# 没有满分
# 语句运行结束

3. 多分支

score=int(input('请输入分数：'))
if score>=90:
    print('A等级')
    pass
elif score>=80:
    print('B等级')
    pass
elif score>=70:
    print('C等级')
    pass
else:
    print('D等级')
    pass
# 示例一：
# 请输入分数：95
# A等级
# 示例二：
# 请输入分数：85
# B等级
# 示例三：
# 请输入分数：75
# C等级
# 示例四：
# 请输入分数：65
# D等级

#猜拳游戏
import random
person=int(input('请出拳：[0：石头 1：剪刀 2：布]'))
computer=random.randint(0,2)
print(computer)
if person==0 and computer==1:
    print('你赢了')
    pass
elif person==1 and computer==2:
    print('你赢了')
    pass
elif person==2 and computer==0:
    print('你赢了')
    pass
elif person==computer:
    print('平局')
    pass
else:
    print('电脑赢了')
    pass

4. 嵌套使用

循环流程

while

1. 语法结构
   while 条件表达式
   ??代码指令
2. 语法特点
   （1）有初始值
   （2）条件表达式
   （3）循环体内计数变量自增或自减
3. 使用条件：循环次数不确定，依靠循环条件来结束

# 循环输出1到100的数字
index=1
while index<=100:
    print(index)
    index+=1
    pass

# 循环10局的猜拳游戏
import random
count=1
while count<=10:
    person=int(input('请出拳：[0：石头 1：剪刀 2：布]'))
    computer=random.randint(0,2)
    print(computer)
    if person==0 and computer==1:
        print('你赢了')
        pass
    elif person==1 and computer==2:
        print('你赢了')
        pass
    elif person==2 and computer==0:
        print('你赢了')
        pass
    elif person==computer:
        print('平局')
        pass
    else:
        print('电脑赢了')
        pass
    count+=1

# 打印九九乘法表
i=9
j=1
while i>=1:
    while j<=i:
        print('{}*{}={}'.format(i,j,i*j),end=' ')
        j+=1
        pass
    print()
    j=1
    i-=1
    pass
# 9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81 
# 8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64 
# 7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49 
# 6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36 
# 5*1=5 5*2=10 5*3=15 5*4=20 5*5=25 
# 4*1=4 4*2=8 4*3=12 4*4=16 
# 3*1=3 3*2=6 3*3=9 
# 2*1=2 2*2=4 
# 1*1=1 

for

1. 语法结构
   for 临时变量 in 字符串，列表等：
   ??执行代码块
2. 语法特点：遍历操作

tags='我是潘小雷'
for item in tags:
    print(item)
    pass
# 我
# 是
# 潘
# 小
# 雷

# range 此函数可以生成一个数据集合列表
# range(起始：结束：步长) 步长不能为0
# 从1到99打印
for data in range(1,100):
    print(data,end=' ')

break和continue

1. break 代表中断结束，满足条件直接结束本层循环
2. continue 结束本次循环，继续的进行下次循环
3. 两个关键字只能用在循环中

for…else…结构

account=1
password=1
for item in range(3):
    input_account=int(input('请输入账号：'))
    input_password=int(input('请输入密码：'))
    if account==input_account and password==input_password:
        print('登录成功')
        break
        pass
    pass
else:
    print('您的账号已被锁定')
# 示例一：
# 请输入账号：11
# 请输入密码：11
# 请输入账号：1
# 请输入密码：11
# 请输入账号：33
# 请输入密码：33
# 您的账号已被锁定

# 示例二：
# 请输入账号：1
# 请输入密码：1
# 登录成功

1. 在上面的循环中，只要出现了break，那么在else中的代码不会执行
2. while…else…同理

字符串操作

序列

1. 序列：在Python当中，序列就是一组按照顺序排列的值
2. 在Python中，存在三种内置的序列类型：字符串、列表、元组
3. 优点：可以支持索引和切片的操作
4. 特征：第一个正索引为0，指向的是左端，第一个索引为负数的时候，指向的是右端

字符串及常用方法

1. 切片是指截取字符串中的其中一段内容。切片使用语法：[起始下标:结束下标:步长]切片截取的内容不包含结束下标对应的数据，步长指的是隔几个下标获取一个字符。
2. 

test='python'
print('第一个字符{}'.format(test[0])) #第一个字符p
for item in test:
    print(item,end=' ')
    pass
#p y t h o n 

print(test.capitalize()) #首字母大写
#Python

test_space=' hello   ' 
print(test_space.strip()) #去除字符串中的空格
#hello
print(test_space.rstrip()) #去除字符串右边的空格
# hello

test_a=1
test_b=a #将test_a的内存地址赋给test_b
print('a的内存地址为%d'%id(test_a))
print('b的内存地址为%d'%id(test_b))
# a的内存地址为140735248344864
# b的内存地址为140735248345888

# 查找目标对象在序列对象中的位置，如果没有找到返回-1
dataStr='I love python'
dataStr.find('o') #3
print(dataStr.index('o')) #3
print(dataStr.startswith('I')) #True
print(dataStr.endswith('o')) #False
print(dataStr.upper()) #I LOVE PYTHON
print(dataStr.lower()) #i love python

# 切片
strMsg='hello world'
print(strMsg)
print(strMsg[0])
print(strMsg[2:5]) #llo 左闭右开
print(strMsg[2:]) #llo world
print(strMsg[:3]) #hel
print(strMsg[::-1]) #dlrow olleh 倒序输出

列表

1. 有序的数据集合
2. 特点
   （1）支持增删改查
   （2）列表中的数据时可以变化的（数据项可以变化，内存地址不会改变）
3. 用[ ]来表示列表类型，数据项之间用逗号分割，注意，数据项可以是任何类型的数据
4. 支持索引和切片来进行操作

li=[1,2,3,"潘潘"]
print(len(li)) #返回列表长度 4

# 查找
listA=['abcd',100,1.2,True]
print(listA) #['abcd', 100, 1.2, True]
print(listA[0]) #abcd
print(listA[1:3]) #[100, 1.2]
print(listA[2:]) #[1.2, True]
print(listA[::-1]) #[True, 1.2, 100, 'abcd']
print(listA*2) #['abcd', 100, 1.2, True, 'abcd', 100, 1.2, True]

# 增加
listA.append(['fff','ddd'])
print(listA) #['abcd', 100, 1.2, True, ['fff', 'ddd']]
listA.insert(1,'插入的数据') #插入到第二个数据的位置
print(listA) #['abcd', '插入的数据', 100, 1.2, True, ['fff', 'ddd']]
rsData=list(range(10)) #强制转换为list对象
print(rsData) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
listA.extend(rsData) #拓展 批量添加 或listA.extend([1,2,3])
print(listA) 
#['abcd', '插入的数据', 100, 1.2, True, ['fff', 'ddd'], 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 修改
listA=['abcd',100,1.2,True]
listA[0]='abcdefg'
print(listA) #['abcdefg', 100, 1.2, True]

# 删除
listB=list(range(10,20))
print(listB) #[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
del listB[0]
print(listB) #[11, 12, 13, 14, 15, 16, 17, 18, 19]
del listB[1:3] #批量删除
print(listB) #[11, 14, 15, 16, 17, 18, 19]
listB.remove(11) #移除指定元素
print(listB) #[14, 15, 16, 17, 18, 19]
listB.pop(0) #移除指定的项（参数是索引）
print(listB) #[15, 16, 17, 18, 19]

元组

1. 不可变的序列，创建之后不能做任何修改(可以对元组中的列表进行修改)
2. 当元组中只有一个元素时，要加上逗号，不然解释器会当做整型处理

tupleA=('abcd',123,1.2)
print(tupleA) #('abcd', 123, 1.2)

# 查找
for item in tupleA:
    print(item,end=' ')
    pass
#abcd 123 1.2
print(tupleA[0]) #abcd
print(tupleA[1:3]) #(123, 1.2)
print(tupleA[::-1]) #(1.2, 123, 'abcd')
print(tupleA[-2:-1:]) #(123,)

tupleB=tuple(range(10))
print(tupleB) #(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
print(tupleB.count(1)) #1 包含了一个1 count可以统计元素出现个数

字典

1. 重要的数据类型
2. 键值对组成的集合
3. 通常使用键来访问数据
4. 支持增删改查
5. 特点：
   （1）不是序列类型，没有下标的概念，无序的键值集合
   （2）键必须是不可变的类型，值可以是任意的类型
   （3）每个键必定是唯一的，如果存在重复的键，后者会覆盖前者

# 创建
dict_test={"pro":'软件工程','school':'东北大学','lesson':'python'}

# 增加 
dictA['name']='潘小雷' #key:value
dictA['age']=20
print(dictA) #{{'name': '潘小雷', 'age': 20} 输出完整的字典
print(len(dictA)) #2

# 查找
print(dictA['name']) #潘小雷
print(dictA.keys()) #dict_keys(['name', 'age'])
print(dictA.values()) #dict_values(['潘小雷', 20])
print(dictA.items()) #dict_items([('name', '潘小雷'), ('age', 20)])
for item in dictA.items():
    print(item)
# ('name', '潘小雷')
# ('age', 20)
for key,value in dictA.items():
    print('%s %s'%(key,value))
# name 潘小雷
# age 20

# 修改
dictA['name']='雨宙'
print(dictA) #{'name': '雨宙', 'age': 20}
dictA.update({'age':19})
print(dictA) #{'name': '雨宙', 'age': 19}
dictA.update({'height':178})
print(dictA) #{'name': '雨宙', 'age': 19, 'height': 178}

# 删除
del dictA['height']
print(dictA) #{'name': '雨宙', 'age': 19}
dictA.pop('age')
print(dictA) #{'name': '雨宙'}

# 按照key排序
sorted(dict_test.items(),key=lambda d:d[0])
# [('lesson', 'python'), ('pro', '软件工程'), ('school', '东北大学')]

# 按照value排序 类型一致才可以排序
sorted(dict_test.items(),key=lambda d:d[1])
# ('lesson', 'python'), ('school', '东北大学'), ('pro', '软件工程')]

公有方法

1. 合并操作
2. 复制
3. 判断元素是否存在

# 合并
strA='人生苦短'
strB='我学Python'
print(strA+strB) #人生苦短我学Python

listA=list(range(10))
listB=list(range(11,20))
print(listA+listB)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19]

# 复制
print(strA*3)
# 人生苦短人生苦短人生苦短
print(listA*2)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 对象是否存在
print('人' in strA) # True
print(5 in listA) # True
dictA={"name":"潘小雷"}
print('name' in dictA) # True 判断key是否在字典中