/******对象******/
-python面向对象的语言
-一切皆对象
-程序运行当中，所有的数据都是存储到内存当中然后在运行
-对象就是内存中专门从来存储数据的一块区域
-对象实际上就是一个容器，专门用来存储数据
-像数值、字符串、布尔值、None都是对象
对象的结构
- 每个对象中都要保存三种数据
- id（标识）
> id用来标识对象的唯一性，每一个对象都有唯一的id
> 对象的id就相当于人的身份证号一样
> 可以通过id()函数来查看对象的id
> id是由解析器生成的，在CPython中，id就是对象的内存地址
> 对象一旦创建，则它的id永远不能再改变
- type（类型）
> 类型用来标识当前对象所属的类型
> 比如：int str float bool 。。。
> 类型决定了对象有哪些功能
> 通过type()函数来查看对象的类型
> Python是一门强类型的语言，对象一旦创建类型便不能修改
- value（值）
> 值就是对象中存储的具体的数据
> 对于有些对象值是可以改变的
> 对象分成两大类，可变对象 不可变对象
可变对象的值可以改变
不可变对象的值不能改变，之前学习的对象都是不可变对象
变量和对象
- 对象并没有直接存储到变量中，在Python中变量更像是给对象起了一个别名
- 变量中存储的不是对象的值，而是对象的id（内存地址），
当我们使用变量时，实际上就是在通过对象id在查找对象
- 变量中保存的对象，只有在为变量重新赋值时才会改变
- 变量和变量之间是相互独立的，修改一个变量不会影响另一个变量
类型转换
- 所谓的类型转换，将一个类型的对象转换为其他对象
- 类型转换不是改变对象本身的类型，而是根据当前对象的值创建一个新对象
is比较两个对象的id
==比较两个对象的值
/******条件控制******/
‘‘‘
编写一个程序，获取一个用户输入的整数。然后通过程序显示这个数是奇数还是偶数
‘‘‘
num=int(input(‘请输入一个整数：‘))
if num%2==0:
print(num,‘这是一个偶数‘)
else:
print(num,‘这是一个奇数‘)
‘‘‘
编写一个程序，检查任意一个年份是否是闰年。
如果一个年份可以被4整除不能被100整除，或者可以被400整除，这个年份就是闰年
‘‘‘
year=int(input(‘请输入一个年份：‘))
if year%4==0 and year%100!=0 or year%400==0:
print(year,‘这一年是闰年‘)
else:
print(year,‘这一年是平年‘)
‘‘‘
编写一个程序，获取用户输入的狗的年龄，然后通过程序显示其相当于人类的年龄。
如果用户输入负数，请显示一个提示信息
狗的前两年每一年相当于人类的10.5岁，然后每增加一年就增加四岁。
那么5岁的狗相等于人类的年龄就应该是10.5+10.5+4+4+4 = 33岁
‘‘‘
dog_age=float(input(‘请输入狗的年龄：‘))
like_person_age=0
if dog_age<0:
print(‘你的输入不合法‘)
if dog_age>0:
if dog_age<=2:
like_person_age=dog_age*10.5
else:
like_person_age=2*10.5
like_person_age+=(dog_age-2)*4
print(dog_age,‘岁的狗年纪相当于‘,like_person_age,‘岁的人‘)
‘‘‘
输入小明的期末成绩:
当成绩为100时，‘奖励一辆BMW‘
当成绩为[80-99]时，‘奖励一台iphone‘
当成绩为[60-79]时，‘奖励一本参考书‘
其他时，什么奖励也没有
‘‘‘
res=int(input(‘请输入成绩：‘))
if 0<=res<=100:
if res==100:
print(‘奖励一辆BMW‘)
elif 80<=res<=99:
print(‘奖励一台iPhone‘)
elif 60<=res<=79:
print(‘奖励一本参考书‘)
else:
print(‘什么奖励也没有‘)
else:
print(‘输入不合法‘)
‘‘‘
女方家长要嫁女儿，当然要提出一定的条件：
高：180cm以上; 富:1000万以上; 帅:500以上;
如果这三个条件同时满足，则:‘我一定要嫁给他‘
如果三个条件有为真的情况，则:‘嫁吧，比上不足，比下有余。‘
如果三个条件都不满足，则:‘不嫁！‘
‘‘‘
sg=180
cf=1000
yz=500
g=int(input(‘请输入身高(厘米):‘))
f=int(input(‘请输入财富(万)：‘))
s=int(input(‘请输入颜值：‘))
if g>=sg and f>=cf and s>=yz:
print(‘我一定要嫁给他‘)
elif g>=sg or f>=cf or s>=yz:
print(‘嫁吧，比上不足，比下有余‘)
else:
print(‘不嫁‘)
/******while循环******/
‘‘‘
while语句在执行时，先对while后的条件表达式进行求值判断
如果判断为True，则执行循环体（代码块），执行完毕继续判断，直到结果为False，循环中止。
循环的三个条件：
初始化表达式，
条件表达式
更新表达式
‘‘‘
i=0
#初始化表达式
while i<10:
#条件表达式
i+=1
#更新表达式
print(i,‘hello‘)
‘‘‘
求100以内所有的奇数之和
‘‘‘
方法一：
i=0
sum=0
#创建一个变量保存结果
while i<100:
i+=1
if i%2!=0:
sum+=i
print(sum)
方法二：
i=1
sum=0
while i<100:
sum+=i
i+=2
print(sum)
‘‘‘
求100以内所有7的倍数之和，以及个数
‘‘‘
i=0
sum=0
while i<100:
i+=1
if i%7==0:
sum+=i
print(sum)
i=7
sum=0
count=0
while i<100:
count+=1
sum+=i
i+=7
print(‘总和为：‘,sum, ‘总次数为：‘,count)
‘‘‘
水仙花数是指一个 n 位数（n≥3 ），它的每个位上的数字的 n 次幂之和等于它本身（例如：1**3 + 5**3 + 3**3 = 153）。
求1000以内所有的水仙花数
‘‘‘
i=100
while i<1000:
a=i//100
b=i//10%10
# b=(i-a*100)//10
c=i%10
if a**3+b**3+c**3==i:
print(i)
i+=1
‘‘‘
获取用户输入的任意数，判断其是否是质数。质数是只能被1和它自身整除的数，1不是质数也不是合数
‘‘‘
num=int(input(‘请输入一个任意的大于1的整数：‘))
i=2
flag=True
#创建一个变量用来记录num是否为质数，默认为质数
while i <num:
if num %i==0:
flag=False
i+=1
if flag:
print(num,‘是质数‘)
else:
print(num,‘不是质数‘)
/******循环嵌套******/
# 创建一个循环来控制图形的高度
# 循环嵌套时，外层循环每执行一次，内层循环执行一圈
‘‘‘
* * * * *
* * * * *
* * * * *
* * * * *
* * * * *
‘‘‘
i=0
while i <5:
#创建一个内层循环来控制图形的宽度
j=0
while j<5:
print(‘* ‘,end=‘‘)
j+=1
print()
i+=1
‘‘‘
* * * * *
* * * *
* * *
* *
*
‘‘‘
i=0
while i <5:
#创建一个内层循环来控制图形的宽度
j=0
while j<5-i:
print(‘* ‘,end=‘‘)
j+=1
print()
i+=1
‘‘‘
*
* *
* * *
* * * *
* * * * *
‘‘‘
i=0
while i <5:
#创建一个内层循环来控制图形的宽度
j=0
while j<i+1:
print(‘* ‘,end=‘‘)
j+=1
print()
i+=1
‘‘‘
九九乘法表
‘‘‘
i=1
while i<10:
j=1
while j<i+1:
print(str(j)+‘*‘+str(i)+‘=‘+str(i*j),end=‘ ‘)
j+=1
print()
i+=1
‘‘‘
求100以内的所有质数
‘‘‘
i=2
while i<=100:
#创建一个变量，记录i的状态，默认为i是质数
flag=True
# 判断i是否是质数
#获取所有可能成为i的因数的数
j=2
while j<i:
#判断i能否被i整除
if i %j==0:
#i能被j整除，证明i不是质数，修改flag为False
flag=False
j+=1
#验证并输出结果
if flag:
print(i)
i+=1
#质数练习优化
from time import *
#优化前：15.3s
#第一次优化：1.6s
#第三次优化：0.05s
begin=time()
i=2
while i<=10000:
flag=True
j=2
while j<=i**0.5:#第二次优化
if i %j==0:
flag=False
#一旦进入判断，则证明i一定不是质数，此时内层循环没有继续执行的必要
break#第一次优化
j+=1
if flag:
pass
# print(i)
i+=1
end=time()
print(end-begin)
‘‘‘
break可以用来立即退出循环语句（包括else）
continu可以用来跳过当次循环
break和continue都是只对离他最近的循环起作用
‘‘‘
/******练习1******/
import time
print(‘=================================欢迎来到唐僧大战白骨精=================================‘)
role = input(‘身份选择\n‘
‘1.唐僧\n‘
‘2.白骨精\n‘
‘请选择：‘)
if role == ‘1‘:
print(‘你好，唐僧‘)
elif role == ‘2‘:
print(‘太不要脸了，系统自动给你分配为唐僧‘)
else:
print(‘你好，你是唐僧‘)
player_att = 2
player_life = 2
boss_life = 10
boss_att = 10
print(‘*‘ * 50)
print(‘唐僧，你的生命值是 %s你的攻击力是 %s‘ % (player_life, player_att))
print(‘*‘ * 50)
time.sleep(1)
while True:
print(‘=‘ * 50)
print(‘请选择操作：‘)
print(‘1.练级‘)
print(‘2.打boss‘)
print(‘3.逃跑‘)
chose = input(‘请选择你要进行的操作：‘)
if chose == ‘1‘:
player_life += 2
player_att += 2
print(‘*‘ * 50)
print(‘唐僧，恭喜你升级了，你的生命值是%s你的攻击力是%s‘ % (player_life, player_att))
elif chose == ‘2‘:
boss_life -= player_att
print(‘-‘ * 50)
print(‘唐僧攻击白骨精‘)
if boss_life <= 0:
print(‘白骨精受到了%s点伤害，挂了，唐僧胜利 ‘ % player_att)
break
player_life -= boss_att
print(‘-‘ * 50)
print(‘白骨精攻击唐僧‘)
if player_life <= 0:
print(‘唐僧受到了%s点伤害，游戏结束 ‘ % boss_att)
break
elif chose == ‘3‘:
print(‘唐僧跑了,游戏结束‘)
break
else:
print(‘你的输入有误，请重新输入‘)
/******序列******/
序列是Python中最基本的一种数据结构
- 数据结构指计算机中数据存储的方式
- 序列用于保存一组有序的数据，所有的数据在序列当中都有一个唯一的位置（索引）
并且序列中的数据会按照添加的顺序来分配索引
- 序列的分类：
可变序列（序列中的元素可以改变）：
> 列表（list）
不可变序列（序列中的元素不能改变）：
> 字符串（str）
> 元组（tuple）
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
/******对象******/
原文：https://www.cnblogs.com/dalton/p/11794500.html