python基础（上篇）【原创真实个人记录】

下面是博主在学习python中的一些笔记记录，以这种文章的形式记录我所做的笔记，一方面是方便我日后的回溯学习，另一方面也是想要看看自己一点一滴的对于编程思想上的进步。对于一些编程小白也是非常友好的，也可以随时来进行查找知识点。本代码全在pyCharm上运行，具体软件的安装与激活不过多介绍，不会的可以在网上搜索，也可以直接私信博主。
当然学习完成后，后序还有下篇与进阶篇和补充。

链接 ：点击此处转入python基础（下篇）.

链接 ： python基础（进阶篇）+实战游戏项目.

python基础（下篇）.
python基础（下篇）.

变量和数据类型

# print('hello , python')
# a就是变量的名字 对应一个盒子 里面装的就是数据10
a=10
#首先程序会根据你所赋值的数据类型开辟相应的内存空间地址
#通过变量的名称进行使用
#变量是可以多次赋值的【在程序的执行过程中 值是可以改变的量】
a='woopsion'
print(a)
#变量是存储数据的。

python基本数据类型

数字：int （有符号整数） long（长整型）（python3取消）

float（浮点型） complex（复数） 布尔型（bool）（ture和false）

字符串（str）字典（dict）元组（Tuple）列表（list）

#type可查看变量的数据类型。
a=100
print(type(a))
#变量是存储数据的。
a='王鹏灿'
print(type(a))
a=True
print(type(a))
a=13.1
print(type(a))

#高级类型
b=()#元组类型
print(type(b))
b=[]#列表类型
print(type(b))
b={}#字典类型
print(type(b))

命名规则：

变量必须以字母（a-z,A-Z或下划线_开头

其他字符可以是字母，数字或_

变量区分大小写

python 关键字不能作为变量名

算术运算符

**指数 左边的是底数，右边的是指数。

%取余数

/除法 j结果包含小鼠点后面的数

//地板除 x//y 结果是忽略小数点后面的小数位，只保留整数。

比较运算符

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

逻辑运算符（优先级）

a,b,c,d=23,18,10,3

print(a+b>c and c<d)
print(c>d and a>b)
#后面有 or  not 取反 真假切换
a,b,c,d=23,18,10,3
#not
print('----------not----------')
print(not a < b)
输出结果：
----------not----------
True
#优先级
()->not->and->or

赋值运算符

#+= -=  *= /= %= **=
a,b,c,d=23,18,10,3
a+=c
print(a)
a**=2#也就是 23*23
print(a)

python输入与输出

输出

name='woopsion'
QQ='1142506659'
phone='123456789'
addr='河南省平顶山市'
print("姓名：%s"%name)
print("QQ：%s"%QQ)
print("phone：%s"%phone)
print("addr：%s"%addr)
#格式输出的其他方式.format
print('---------format---------')
name='woopsion'
QQ='1142506659'
phone='123456789'
addr='河南省平顶山市'
print('姓名：{}'.format(name))
print('QQ号码：{}'.format(QQ))
print('电话号码：{}'.format(phone))
print('地址：{}'.format(addr))

输入

input

name=input("请输入姓名：")
QQ=input("请输入QQ号码：")
phone=input("请输入电话号码：")
addr=input("请输入地址情况：")
print('姓名：{}'.format(name))
print('QQ号码：{}'.format(QQ))
print('电话号码：{}'.format(phone))
print('地址：{}'.format(addr))

另外还有关于，数据类型的错误例子

name=input("请输入姓名：")
print(type(name))
age=input('请输入年龄')
QQ=input("请输入QQ号码：")
phone=input("请输入电话号码：")
addr=input("请输入地址情况：")
print('姓名：%s年龄是：%d岁'%(name,age))
# print('姓名：{} 年龄是{}岁'.format(name,age))
输出结果是：
请输入姓名：王鹏灿
<class 'str'>
请输入年龄20
请输入QQ号码：1231213
请输入电话号码：123123
请输入地址情况：123123
Traceback (most recent call last):
  File "d:\python\人工智能\index\输出.py", line 7, in <module>
    print('姓名：%s年龄是：%d岁'%(name,age))
TypeError: %d format: a number is required, not str
#改错的方法，强制使用int去转换输入类型
#
#
#
#
name=input("请输入姓名：")
print(type(name))
age=int(input('请输入年龄'))
QQ=input("请输入QQ号码：")
phone=input("请输入电话号码：")
addr=input("请输入地址情况：")
print('姓名：%s年龄是：%d岁'%(name,age))
# print('姓名：{} 年龄是{}岁'.format(name,age))
print('QQ号码：{}'.format(QQ))
print('电话号码：{}'.format(phone))
print('地址：{}'.format(addr))
###
###
#输出结果：
请输入姓名：王鹏灿
<class 'str'>
请输入年龄20
请输入QQ号码：12312312312
请输入电话号码：1231231231
请输入地址情况：萨勒夫静安寺    
姓名：王鹏灿年龄是：20岁
QQ号码：12312312312
电话号码：1231231231
地址：萨勒夫静安寺
错误消失了

流程结构控制

1.条件语句

score=80
if score<=60: #记得这里有个“:”
   print("成绩不是太理想")
   pass
print("语句运行结束")
#----------分割线------------
#----------双分支------------
if score >60:
    print("你的成绩及格了...")
    pass
else:
    print("成绩不合格，请继续努力")
    pass
#----------分割线------------
#----------多分支------------
···if 条件表达式：（比较运算符 逻辑运算符 /复合条件表达式）
         代码指令
   elif 条件表达式：
         代码指令
   .....
   els:
#特征：只要满足其中一个分支，就会退出本层if语句结构【必定会执行其中一个分支】      
#至少有两种情况可以选择
#elif 后面必须的写上条件和语句
#else 是选配，根据实际的情况来填写


···

score=int(input("请输入您的成绩"))
if score>=90:
    print("您的成绩为A")
    pass
elif score>=80:
    print("您的成绩为B")
    pass
elif score>=70:
    print("您的成绩为C")
    pass
elif score>=60:
    print("您的成绩为D")
    pass
else:
    print("请回家种地，谢谢")

猜拳小游戏

#石头剪刀布
print("0：石头 1：剪刀 2：布")

import random#直接导入随机数的模块
#计算机   人
person=int(input("请出拳"))
computer=random.randint(0,2)
if person==0 and computer==1:
    print('电脑出拳为{}'.format(computer))
    print("厉害了。。你赢了")
    pass
elif person==1 and computer==2:
    print('电脑出拳为{}'.format(computer))
    print("厉害了。。你赢了")
    pass
elif person==computer:
    print('电脑出拳为{}'.format(computer))
    print("不错 居然是平手")
    pass
else:
    print('电脑出拳为{}'.format(computer))
    print("哈哈...你输了吧")

2.循环

while

#while  循环的分类
#while 语法结构
#while 条件表达式：
#      代码指令
#语法特点
#1.有初始值
#2.条件表达式
#3.变量【循环体内计数变量】的自增自减，否则会造成死循环
#使用的条件：循环的次数不确定，是依靠循环条件来 结束
#目的： 为了将相似或者相同的代码操作变得更加简洁，使得代码可以重复利用
#for




#while的使用
#案例 输出1-100之间的数据
index=1
while index<=100:
    print(index)
    index+=1
    pass

九九乘法表（while and fof）

row=1
lie=1
while row<=9:
    while lie<=hang:
        print("{}*{}={}".format(row,lie,row*lie),end="")
        lie+=1
        pass
    print()
    lie=1
    row+=1
    pass
注意end=""的使用一般情况下在python中，是打印一行自动换行，而在C++语言中需要使用到endl；进行换行，一般情况下是不换行的，所以在python中想要不换行就添加end=" "在打印的后面进行空字符串的赋值，这样就不会换行了，等这个循环结束在加上
print()
就能自动换行。

print("用for循环实现九九乘法表")
print("----------------分割线---------------")
for item in range(1,10):
    for j in range(1,item+1):
        print("%d*%d=%d"%(item,j,item*j),end=" ")
    print(" ")
    item+=1

等腰三角形

row=1
while row<=5:
    j=1
    while j<=5-row:
        print(" ",end=" ")
        j+=1
        pass
    k=1
    while k<=2*row-1:
        print("*",end=" ")
        k+=1
        pass
    print()
    row+=1
    pass

for

#语法特点：遍历操作，依次的取集合容器中的每个值
#for 临时变量 in  容器：
#     执行代码块
tags="我是一个中国人"
for item in tags:
    print(item)
    pass
#range 此函数可以生成一个数据集合列表
#range（起始：结束：步长） 步长不能为0

# for data in range (1,101):
#     print(data,end=" ")

# sum=0
# for data in range (1,101):
#     sum+=data
#     # print(sum,end=" ")
#     pass
# print("sum=%d"%(sum))

print("-------------for的使用-----------------")
for data in range (50,201):
    if data%2==0:
        print("%d是偶数"%data)
        pass
    else:
        print("%d是奇数"%data)
        pass
    pass

break&continue

#break 和continue
#break 代表中断结束   满足条件直接的结束本层循环
#continue： ，继续的进行下次循环（当continue的条件满足的时候，本次循环剩下的语句将不在执行)
#后面的循环继续
#这两个关键字只能用在循环中。
# sum=0
# for item in range (1,51):
#
#     if sum>100:
#         print("循环执行到%d就退出来了"%item)
#         break
#         pass
#     sum += item
#     print(sum)
#     pass
# print("sum=%d"%(sum))


# for item in range (1,101):
#     if item%2!=0:
#         continue
#         pass
#     print(item)
#     pass


for item in "l love python":

#     if item=="e":
#         continue
#         pass
#     print(item)
#     pass
    if item == "o":
        continue
        pass
    print(item)

while使用：适用于对未知的循环次数 用为判断

for 使用 ：适用与已知的循环次数

猜拳游戏

import random
computer_year = random.randint(1, 10)#自己定义年龄的范围
mind="Y"#玩家是否想继续游戏的想法，初始是Y
player="begin"#记录玩家游戏的状态
while mind=="y"or mind=="Y":
  for i in range(3):
    player_guess = int(input("请输入您所猜测的年龄大小--范围是（1-10岁）"))
    if  player_guess==computer_year:
            print("恭喜您猜对了。")
            player="win"
            break
    elif player_guess<computer_year:
            print("您猜小了，请重试")
    else:
        print("您猜大了，请重试")
  if player=="win":
      mind="s"
  else:
        print("您已经猜错三次，游戏结束，是否还想继续？请输入Y或者y")
        mind=input("请输入")

判断体重BMI公式

high=float(input("请输入您的身高，单位是米"))
weight=float(input("请输入体重，单位kg"))
BMI=weight/(high**2)
if BMI<=18.5:
    print(('您的体重过轻'))
elif BMI>18.5 and BMI<25:
    print("您的体重正常")
elif BMI>=25 and BMI<28:
    print("您的体重过重")
elif BMI>=28 and BMI<32:
    print("您的体重肥胖")
else :
    print("您的体重严重肥胖")

高级数据类型

**序列：**在python当中 序列就是一组按照顺序排列的值【数据集合】

在python中 存在三种内置的序列类型

字符串、列表、元组。

优点：可以支持索引和切片的操作

特征：第一个正索引为0，指向的是左端，第一个索引为负数的时候指向的是右端

切片【高级特性】是指截取字符串中的其中一段内容。 切片使用语法：

[satrt:end:step]step默认1

字符串

关于字符串的操作

# test="paython"
# print("获取一个字符%s"%test[0])
# print("获取二个字符%s"%test[1])
# print("获取倒数第一个字符%s"%test[-1])
# print("获取倒数第二个字符%s"%test[-2])
# name="peter"
# # print("首字母大写%s"%name.capitalize())  capitalize 首字母变大写
# #删除空格
# a="           hello         "
# b=a.strip()
# print(b)
# c=a.lstrip()#删除左空格
# print(c)
# d=a.rstrip()#删除右空格
# print(d)
# print("a的内存地址%d"%id(a))
# b=a
# print("b的内存地址%d"%id(b))
# #内存地址一样。
# print(b)#复制字符串
#
# dataStr='I  love Python'
# print(dataStr.find('P'))#可以查找目标对象在序列对象中的下标值,无法找到是-1
# print(dataStr.index('P'))#可以查找目标对象在序列对象中的下标值，无法找到报错
# print(dataStr.startswith('I'))#判断首字符是否是“I”
# print(dataStr.endswith('n'))#判断末尾字符是否是“n”
#
# print(dataStr.lower())#将字符串全部变为小写
# print(dataStr.upper())#讲字符串全部变为大写
strMsg='hello word'
# slice[start:end:step]  切片的输出字符段是左闭右开的
print(strMsg[2:6])
print(strMsg[2:7])
#-----------打印结果-------
#llo 
#llo w

#-----------分割线-----------
strMsg='hello word'
# slice[start:end:step]  切片的输出字符段是左闭右开的
print(strMsg[2:6])
print(strMsg[2:7])
print(strMsg[2:])#这个是可以取出下标为2的之后的所有字符
print(strMsg[0:3])#这个可以是取出第一个到第三个字符strMsg[:3]=strMsg[0;3]
print(strMsg[::-1])#倒序输出

列表

#list: python 当中非常重要的数据结构，是一种有序的数据集合
#特点：
#1：支持增删改查
#2：列表中的数据是可以变化的【数据项可以变化，内存地址不会改变】
#3：用[]来表示列表类型，数据项之间用逗号来分割，注意：数据可以是任何类型的数据
#4.支持碎银和切片来进行操作

关于列表的操作

#list: python 当中非常重要的数据结构，是一种有序的数据集合
#特点：
#1：支持增删改查
#2：列表中的数据是可以变化的【数据项可以变化，内存地址不会改变】
#3：用[]来表示列表类型，数据项之间用逗号来分割，注意：数据可以是任何类型的数据
#4.支持碎银和切片来进行操作



#---------------len函数的使用------------
#li=[]#空列表
# li=[1,2,3,"你好"]
# print(len(li))#len 函数可以获取到列表对象中的数据个数
# strA='我喜欢python'
# print(len(strA))
# print(type(li))


#查找
listA=['abcd',785,12.23,'qiuzhi',True]
print(listA)#输出完整的列表
print(listA[0])#输出第一个元素
print(listA[1:3])#从第二个开始到第三个元素
print(listA[2:])#从第三个元素开始到最后所有的元素
print(listA[::-1])#负数表示列表从右向左开始打印元素
print(listA*3)#输出多次列表中的数据【复制】
print("---------追加----------")
print('追加之前',listA)
listA.append(['fff','ddd'])
print('追加之后',listA)
# listA.append(['8888'])
# print('追加之后',listA)
# listA.insert(1,'这是我刚插入的数据')#插入操作，要选定插入的位置
# print(listA)
#
# rsData=list(range(10))#强制转换为list对象
# print(type(rsData))
# listA.extend(rsData)#拓展，等于批量添加
# print(listA)
# listA.extend([11,22,33,44])
# print(listA)
#也可以直接添加列表





 print('-------------修改------------')
# print('修改之前',listA)
# listA[0]='peter'
# print('修改之后',listA)
# listA[1]=23
# print(listA)
#
#
#
 print('------------删除list数据项-------------')
listB=list(range(10,50))
# print(listB)
# del listB[0]#删除列表中的第一个元素
# print(listB)
# del listB [1:3]#切片的去除还是左闭右开
# print(listB)
#
# listB.remove(20)#移除指定元素  参数是具体的数据值，也是就括号里放列表的具体元素值
# listB.pop(1)#可以移除指定的项 参数是索引值，也就是元素所在list的下标值
print(listB)
print(listB.index(19:20:51))#index 后面两个参数值的意思是在下表为20到小标为50中的元素之间查找19元素print(listB.index(19,10,25))#index 后面两个参数值的意思是在下表为20到小标为50中的元素之间查找19元素
print(listB.index(19,9,25))#index 后面两个参数值的意思是在下表为20到小标为50中的元素之间查找19元素

元组

关于元组的操作

# #元组：是一种不可变的序列，在创建之后不能做任何的修改
# 1：不可变
# 2：用（）创建元组类型，数据项用逗号来分割
# 3：可以是任何的类型
# 4：当元组中只有一个元素时，要加上逗号，不然解释器会当作整形来处理
# 5：同样可以支持切片操作


#元组的创建  不能进行修改

tupleA=()#空元组
tupleB=('abcd',89,9.12,'peter',[11,22,33])
print(type(tupleB))
print(type(tupleB))

# 元组的查询
for item in tupleB:
    print(item,end='')
print(tupleB[2:4])
print(tupleB[::-1]) #倒顺打印元组
print(tupleB[::-2])#倒顺序，隔一个元素取一个


print(tupleB[-2:-1:])#倒着取下标  为-2 到-1 区间的

print(tupleB[-4:-2])#倒着取下标 ，为-4到-2区间的元素

#··················同样遵循左闭右开的原则。

tupleB[4][0]='2358'
print(tupleB)
#元组不可以修改，但是元组中的 列表可以进行修改

tupleC=('i love you ')
print(type(tupleC))
#所以当元组中只有一个元素而且不加”，“的情况下，其数据类型不是tuple
tupleC=('i love you ',)
print(type(tupleC))
#加上”，“才不会改变其tuple 的数据类型的结构


tupleD=tuple(range(10))
print(tupleD)

#打印出元组中包含几个8 的数量
print(tupleD.count(8))

字典

关于字典的操作

# 字典： 也是python 中重要的数据类型，字典是由 键值对组成的集合，通常
#使用键来访问数据，效率非常高，和list一样  支持对数据的添加、修改、删除
# 特点：
# 1：不是序列类型，没有下标的概念，是一个无序的 键值集合，是内置的高级数据类型
# 2：用{}来表示字典对象，每个键值对用逗号隔开
# 3：键 必须是不可变的类型【元组、字符串】值可以是任意类型
# 4：每个键必定是唯一 的，如果存在重复的键，后者会覆盖前者
# 如何创建字典：



# dictA={}
# print(type(dictA))
dictA={"name":'王钰','age':'14'}#赋值是一个key：values  key不能重复，而value可重复
dictA['pos']='学生'
#这两种赋值的形式  结合c++的class和c中的struct去理解
print(len(dictA))
#一个逗号是一个项
print(dictA)

#查找
print(dictA['name'])#通过关键词获取值

dictA['name']='谢霆锋'  #修改对应的值

dictA['age']='48'
print(dictA)

print(dictA.keys())#获得所有的关键字

print(dictA.values())#获取所有的值

print(dictA.items())#全部获取

for key,value in dictA.items():
    print('%s==%s'%(key,value))


dictA.update({'name':'hhhh'})
print(dictA)
dictA.update({'height':'90'})
print(dictA)

#可以添加或者修改

# print('-----------删除-----------')
#
#
# del dictA['name']
# dictA.pop('age')  #通过指定键进行删除
#
# print(dictA)


print('-------------排序-------------')

#如何在字典中排序

#按照key进行排序  Ascall码
print(sorted(dictA.items(),key=lambda d:d[0]))

#讲d[0]->d[1] 则是根据value进行排序
print(sorted(dictA.items(),key=lambda d:d[1]))

点击进入！！python基础（下篇）.
点击进入！！python基础（下篇）.
点击进入！！python基础（下篇）.
点击进入！！python基础（下篇）.
点击进入！！python基础（下篇）.
点击进入！！python基础（下篇）.