Python编程基础（一）

最新推荐文章于 2024-05-22 10:45:59 发布

雨宙

最新推荐文章于 2024-05-22 10:45:59 发布

阅读量758

点赞数 2

文章标签： python

本文链接：https://blog.csdn.net/rainy_universe/article/details/119207510

版权

Python编程基础（一）

打卡第一天啦！！！

认识Python

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

变量和数据类型

变量

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

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

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

数据类型

数字（num）

int（有符号整数）
long（长整型)
float（浮点型）
complex（复数）
布尔值（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'>

变量的命名规则

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

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

变量的命名规范

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

算数和比较运算

算数运算

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

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

比较运算

等于==
不等于！=
大于>
小于<
大于或等于>=
小于或等于<=

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

结果是bool类型的数据

逻辑运算符

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

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

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

not取反，真假切换

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

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

赋值运算符

= 赋值运算符
+= 加法赋值运算符
-= 减法赋值运算符
*= 乘法赋值运算符
/= 除法赋值运算符
%= 取模赋值运算符
**= 幂赋值运算符
//= 取整赋值运算符

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）循环流程

选择流程

单分支

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

双分支

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

多分支

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

嵌套使用

循环流程

while

语法结构
while 条件表达式
代码指令
语法特点
（1）有初始值
（2）条件表达式
（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

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

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

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

break和continue

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

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
# 登录成功

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

字符串操作

序列

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

字符串及常用方法

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

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）列表中的数据时可以变化的（数据项可以变化，内存地址不会改变）
用[ ]来表示列表类型，数据项之间用逗号分割，注意，数据项可以是任何类型的数据
支持索引和切片来进行操作

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]

元组

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

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）每个键必定是唯一的，如果存在重复的键，后者会覆盖前者

# 创建
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', '软件工程')]

公有方法

合并操作
复制
判断元素是否存在

# 合并
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是否在字典中

雨宙

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Python编程基础（一）

Python编程基础（一）打卡第一天啦！！！认识Python面向对象解释型计算机程序设计语言胶水语言变量和数据类型变量程序中用变量存储数据变量的定义：变量名=数据变量使用：通过变量名来使用变量a=10print(a) #10a='潘小雷'print(a) #潘小雷首先定义变量，才能使用变量赋值变量时不需要指定数据类型，给这个变量赋值什么数据类型，这个变量就是什么类型数据类型数字（num）int（有符号整数）long（长整型)float（浮点型）co
复制链接

扫一扫