Python编程基础

Posted 雨宙

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Python编程基础相关的知识,希望对你有一定的参考价值。

Python编程基础(一)

打卡第一天啦!!!

认识Python

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

变量和数据类型

变量

  1. 程序中用变量存储数据
  2. 变量的定义:变量名=数据
  3. 变量使用:通过变量名来使用变量
a=10
print(a) #10
a='潘小雷'
print(a) #潘小雷
  1. 首先定义变量,才能使用变量
  2. 赋值变量时不需要指定数据类型,给这个变量赋值什么数据类型,这个变量就是什么类型

数据类型

数字(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
  1. 结果是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
  1. or条件有一个为真,结果就为真
a,b,c,d=23,18,10,3
print(a<b or b>d) #True
print(a<b or b<d) #False
  1. not取反,真假切换
a,b,c,d=23,18,10,3
print(not a>b) #False
  1. 优先级 ()-》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('语句运行结束')
# 满分啦
# 语句运行结束
  1. 双分支
score=99
if score==100:
    print('满分啦')
    pass #空语句
else:
    print('没有满分')
    pass
print('语句运行结束')
# 没有满分
# 语句运行结束
  1. 多分支
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
  1. 嵌套使用

循环流程

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. 切片是指截取字符串中的其中一段内容。切片使用语法:[起始下标:结束下标:步长]切片截取的内容不包含结束下标对应的数据,步长指的是隔几个下标获取一个字符。
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以上是关于Python编程基础的主要内容,如果未能解决你的问题,请参考以下文章

Python基础数据类型考试题

python基础

第一部分基础知识小结,基础数据类型到循环

2018年9月Python计算机二级复习攻略

Python_试题_23

803计算机学科基础综合