Python-01-基础篇

Python 基础篇(一)

学习视频地址

Python中的输出函数

print()函数

• 我里面有一个你可以直接使用的函数叫print()，可以将你想展示的东东在IDLE或标准的控制台上显示

print()的函数的使用

• print()函数可以输出那些内容?
  1. print()函数输出的内容可以是数字
  2. print()函数输出的内容可以是字符串
  3. print()函数输出的内容可以是含有运算符的表达式
• print()函数可以将内容输出的目的地
  1. 显示器
  2. 文件
• print()函数的输出形式
  1. 换行
  2. 不换行

##可以输出数字
print(520)
print(666.666)

##可以输出字符串
print('HelloWorld')
print("HelloWorld")

##含有运算符的表达式
print(3+1) #3和1是操作数 +是运算符

#将数据输出文件中,注意点：
##1.所指定的盘存在
##2.使用file=XX
fp=open('E:/test.txt','a+')##如果文件不存在就创建，存在就在文件内容的后面继续追加
print('HelloWorld',file=fp)
fp.close()

## 不进行换行输出 (输出内容在一行当中)
print('Hello','World','Python')

转义字符

什么是转义字符

• 就是反斜杠+想要实现的转义功能首字母

为什么需要转义字符

• 当字符串中包含反斜杠、单引号和双引号等有特殊用途的字符时，必须使用反斜杠对这些字符进行转义（转换一个含义)

  反斜杠:\
  

  单引号:\'

  双引号:\"

• 当字符串中包含换行、回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符当字符串中包含换行、回车，水平制表符或退格等无法直接表示的特殊字符时，也可以使用转义字符

  换行:

  回车:平制表符:格:\b

# 转义字符
print('Hello\nWorld') #\ +转义功能的首字母  n-->newLine的首字母表示换行  光标移动到下一行的开头
print('Hello\tWorld')                          #Hello	World
print('Hellooo\tWorld') #四个字符是一个制表位     #Helloooooo World   tab键
print('Hello\rWorld')  #World将Hello进行了覆盖  #World    r-->return光标移动到本行的开头
print('Hello\bWorld')  #\b是退一格，将o干掉了    #HellWorld    b-->键盘上backspace键，回退一个字符

print('http:\\\\www.baidu.com')
print('老师说\‘大家好\’')

#元字符,不希望字符串中的转义字符起作用，就使用原字符，就是在字符串之前加上r或R
print(r'Hello\nWorld')
#注意事项，最后一个字符不能是反斜线
# print(r'Hello\nWorld') 报错
print(r'Hello\nWorld\\')

Python 基础篇(二)

二进制与字符编码

print(chr(0b100111001011000))  #乘
print(ord('乘')) ##20056

Python中的标识符和保留字

• 我的保留字

  • 有一些单词我赋予了特定的意义，这些单词你在给你的任何对象起名字的时候都不能用

    import keyword
    print(keyword.kwlist)

• 我的规则你必须知道

  • 变量、函数、类、模块和其它对象的起的名字就叫标识符
  • 规则:
    • 字母、数字、下划线
    • 不能以数字开头
    • 不能是我的保留字
    • 严格区分大小写

变量的定义和使用

• 变量是内存中一个带标签的盒子

• 变量由三部分组成
  • 标识:表示对象所存储的内存地址,使用内置函数id(obj)来获取
  • 类型:表示的是对象的数据类型,使用内置函数type(obj)来获取
  • 值:表示对象所存储的具体数据， 使用print(obj)可以将值进行打印输出

• 当多次赋值后,变量名会指向新的空间

数据类型

• 常用的数据类型

  • 整数类型->int
  • 浮点数类型->float
  • 布尔类型->bool->True,False
  • 字符串类型->str->人生苦短，我用Python:stuck_out_tongue_winking_eye:

• 整数类型

  • 英文为integer,简写为int,可以表示正数、负数和零

  • 整数的不同进制表示方式

    • 十进制->默认的进制
    • 二进制->以0b开头
    • 八进制->以0o开头
    • 十六进制->以0x开头

    整数的进制

    进制	基本数	逢几进一	表示形式
    十进制	0,1,2,3,4,5,6,7,8,9	10	118
    二进制	0,1	2	0b1110110
    八进制	0,1,2,3,4,5,6,7	8	0o166
    十六进制	0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F	16	0x76

  ## 整数类型
  ## 可以表示正数，负数，0
  n1=90
  n2=-76
  n3=0
  print(n1,type(n1))
  print(n2,type(n2))
  print(n3,type(n3))
  #整数可以表示为二进制，十进制，八进制，十六进制
  print('十进制',110)
  print('二进制',0b10101111)   #175
  print('八进制',0o176)        #126
  print('十六进制',0x1EAF)

• 浮点类型

  • 浮点数由整数部分和小数部分组成

  • 浮点数存储不精确性

    • 使用浮点数进行计算时，可能会出现小数位数不确定的情况

    print(1.1+1.2) #3.3000000000000003
    print(1.1+2.1) #3.2

    • 解决方案
      • 导入模块decimal

    from decimal import Decimal
    print(Decimal('1.1')+Decimal('2.2')) #3.3

• 布尔类型

  • 用来表示真或假的值

  • True表示真，False表示假

  • 布尔值可以转化为整数

    • True->1
    • False->0

    print(True+1) #2
    print(False+1)#1

f1=True
f2=False
print(f1,type(f1))
print(f2,type(f2))


# 布尔值可以转成整数计算
print(f1+1) #2       1+1的结果为2，True表示1
print(f2+1) #1       0+1的结果为1，False表示1

• 字符串类型
  • 字符串又被称为不可变的字符序列
  • 可以使用单引号''双引号""三引号'" "'或“”“ ”“”来定义
  • 单引号和双引号定义的字符串必须在一行
  • 三引号定义的字符串可以分布在连续的多行

str1='人生苦短，我用Python'
str2="人生苦短，我用Python"
str3="""人生苦短，
        我用Python"""
str4='''人生苦短，
        我用Python'''
print(str1,type(str1))
print(str2,type(str2))
print(str3,type(str3))
print(str4,type(str4))

数据类型的转换

• 为什么需要数据类型的转换?
  • 将不同数据类型的数据拼接在一起

name='张三'
age=20

print(name,type(name))
print(age,type(int)) #name与age的数据类型不相同
#print('我叫'+name+'今年'+age+'岁')  #当讲str类型与int类型进行连接时，报错，解决方案，类型转换
print('我叫'+name+'今年'+str(age)+'岁') #将int类型通过str()函数转成了str类型

print('---------------------str()将其他类型转成str类型----------------------')
a=10
b=198.8
c=False
print(type(a),type(b),type(c))
print(str(a),str(b),str(c),type(str(a)),type(str(b)),type(str(c)))

print('--------------------int()将其他的类型转int类型-----------------------')
s1='128'
f1=98.7
s2='76.77'
ff=True
s3='hello'
print(type(s1),type(f1),type(s2),type(ff),type(s3))
print(int(s1),type(int(s1)))  #将str转成int类型，字符串为数字
print(int(f1),type(int(f1)))  #将float转成int类型，截取整数部分,舍掉小数部分
#print(int(s2),type(int(s2)))  #将str转成int类型，报错，因为字符串为小数串
print(int(ff),type(int(ff)))
#print(int(s3),type(int(s3))) #将str转成int类型时,字符串必须为字串(整数),非数字串是不允许转换的


print('-------------------------float()函数,将其他类型转为float类型----------------------------')
s1='128.98'
s2='76'
ff=True
s3='hello'
i=98
print(type(s1),type(s2),type(ff),type(s3),type(i))
print(float(s1),type(float(s1)))
print(float(s2),type(float(s2)))
print(float(ff),type(float(ff))) #1.0
# print(float(s3),type(float(s3))) #字符串中的数据如果是非数字串，则不允许转换
print(float(i),type(float(i)))

Python注释

• 注释

  • 在代码中对代码的功能进行解释说明的标注性文字，可以提高代码的可读性

  • 注释的内容会被Python解释器忽略

  • 通常包括三种类型的注释

    • 单行注释->以"#"开头，直到换行结束

    • 多行注释->并没有单独的多行注释标记，将一对三引号之间的代码称为多行注释

    • 中文编码声明注释->在文件开头加上中文声明注释,用以指定源码文件的编码格式

    #coding:gbk

Python 基础篇(三)

Python的输入函数input()

• input()函数的介绍

• input()函数的基本使用

# 从键盘录入两个整数,计算两个整数的和
a=int(input('请输入一个加数:'))
# a=int(a)
b=int(input('请输入另一个加数:'))
# b=int(b)
print(type(a),type(b))
print(a+b)

Python中的运算符

算术运算符

print(1+1)  #执行加法运算
print(1-1)   # 减法运算
print(1*2)   # 乘法运算
print(1/2)   # 除法运算
print(11//2)  # 整除运算
print(11%2)   # 取余 1
print(2**2)  # 2的2次方 4
print(2**3)  # 2的3次方 8

运算符	表示	例子	结果
+	加	1+1	2
-	减	1-1	0
*	乘	2*4	8
/	除	1/2	0.5
%	取余(一正一负要公式)	9%4	1
%	余数=被除数-除数*商	9%-4 9-(-4)*(-3)	-3
**	幂运算	2**3	8
//	整数(一正一负向下取整)	11/2	5
//	整数(一正一负向下取整)	9//-4	-3
//	整数(一正一负向下取整)	-9//4	-3

print(9//4)    #2
print(-9//-4)  #2
print(9//-4)  #-3
print(-9//4)   #-3  一正一负的整数公式，向下取整

print(9%-4)   #-3   公式: 余数=被除数-除数*商  9-(-4)*(-3)   9-12  -3
print(-9%4)  #3                            -9-4*(-3)    -9-(-12) 3

赋值运算符

# 赋值运算符 运算顺序 从右到左
i=3+4
print(i)

a=b=c=20 #链式赋值
print(a,id(a))
print(b,id(b))
print(c,id(c))
print('-----------------参数赋值---------------')
a=20
a+=30 #相当于a=a+30
print(a)   # 相当于a=1-10
a-=10
print(a)
a*=2   # 相当于  a=a*2
print(a)
a/=3
print(a)
print(type(a))
a//=2
print(a)
print(type(a))
a%=3
print(a)

print('----------------解包赋值----------------')
a,b,c=20,30,40 #值和变量个数相等
print(a,b,c)

# a,b=20,30,40 报错
print('--------------交换两个变量的值---------------')
a,b=10,20
print('交换之前:',a,b)
# 交换
a,b=b,a
print('交换之后:',a,b)

比较运算符

# 比较运算符的结果为bool类型
a,b=10,20
print('a>b',a>b)  #False
print('a<b',a<b)  # True
print('a<=b',a<=b) # True
print('a>=b',a>=b) # False
print('a==b',a==b)  # False
print('a!=b',a!=b)  # True

'''一个 =称为赋值运算符，==称为比较运算符
 一个变量有三部分组成，标识，类型，值
 == 比较的是值
 比较对象的标识 使用  is
 '''

a=10
b=10
print(a==b) # True 说明a与b的value相等
print(a is b) # True 说明a与b的id标识，相等


lst1=[11,22,33,44]
lst2=[11,22,33,44]
print(lst1==lst2) #value   True
print(lst1 is lst2) #id   False
print(id(lst1))
print(id(lst2))

print(a is not b) # False  意思是:a的id和b的id结果是不相等的
print(lst1 is not lst2) #  True

布尔运算符

运算符	运算数		运算结果	备注
and	True	True	True	当两个运算数都为True时,运算结果才为True
	True	False	False
	False	True	False
	False	False	False
or	True	True	True	只要有一个运算符为True,运算结果就为True
	True	False	True
	False	True	True
	False	False	False
not	True		False	如果运算符为True,运算结果为False
	False		True	如果运算符为False,运算结果为True

位运算符

a,b=1,2
print('---------------and并且-----------------')
print(a==1 and b==2) #True  True True ->True
print(a==1 and b<2) # True  False -> False
print(a!=1 and b==2) # False True -> False
print(a!=1 and b!=2) # False False -> False

print('---------------or或者------------------')
print(a==1 or b==2)  # True True ->True
print(a==1 or b<2)  # True False -> True
print(a!=1 or b==2) # False True ->True
print(a!=1 or b!=2) # False False -> False


print('----------------not取反 对bool类型操作数取反----------------')
f=True
f2=False
print(not f) #False
print(not f2) # True

print('---------------- in 与 not in --------------------')
s='HelloWorld'
print('w'in s)  #F
print('k' in s) #F
print('W' not in s) #F
print('b' not in s) #T

print(4&8) #按位与& 同为1时 ，结果为1
# 000000100
# 000001000 所以结果为0
print(4|8)# 按位或|  同为0时，结果为0
# 000000100
# 000001000 所以结果为 000001100 12
print(4<<1) #向左移动一位 (移动一个位置)  想当于乘以2
print(4<<2) #向左移动2位  (移动2个位置)  相当于乘4
# 00000100 00001000 高位溢出 低位补零 00010000
print(4>>1) #向右移动1位，相当于除以2
print(4>>2)
# 00000100 00000010 高位补零 低位截断 00000010

运算符的优先级

• 算术运算符
  • 位运算符
    • 比较运算符
      • 布尔运算符
        • 赋值运算符

Python 基础篇(四)

程序的组织结构

• 1996年，计算机科学家证明了这样的事实:任何简单或复杂的算法都可以由顺序结构、选择结构和循环结构这三种基本结构组合而成。

顺序结构

• 程序从上到下顺序地执行代码，中间没有任何的判断和跳转,知道程序结束。

print('--------程序开始---------')
print('1.把冰箱门打开')
print('2.把大象放冰箱里')
print('3.把冰箱门关上')
print('--------程序结束---------')

选择结构

• 单分支结构

money=1000  #余额
s=int(input("请输入取款金额:"))  #取款金额
#判断余额是否充足
if money >=s:
    money=money-s
    print('取款成功~,余额为:',money)

• 双分支结构

# 双分支结构if...else 二选一执行
'''从键盘录入一个整数，编写程序让计算机判断是奇数还是偶数'''
num=int(input('请输入一个整数：'))


# 条件判断
if num%2==0:
    print(num,'num是偶数')
else:
    print(num,'num是奇数')

• 多分支结构

# 多分支结构 ，多选一执行
''' 从键盘录入一个整数 成绩
    90-100 A
    80-89  B
    70-79  C
    60-69  D
    0-59   E
    小于0大于100为非法数据(不是成绩的有限范围)
    '''
score=int(input('请输入一个成绩:'))
# 判断
if 90 <= score <= 100:
    print('A级')
elif 80 <= score <= 89:
    print('B级')
elif 70<= score<=79:
    print('C级')
elif 60<=score<=69:
    print('D级')
elif 0<=score<=59:
    print('E级')
else:
    print('对不起，成绩有误，不在成绩的有效范围')

• 嵌套if

'''会员 >=200 8折
        >=100 9折
            不打折
    非会员 >=200 9.5折
        不打折'''
answer=input("您是会员吗？y/n")
money=float(input("输入你的购物金额:"))
#外层判断是否是会员
if answer=='y':#会员
    if money>=200:
        print('打八折,付款金额为:',money*0.8)
    elif money>=100:
        print('打九折,付款金额:',money*0.9)
    else:
        print('不打折,付款金额为:',money)
else: #非会员
    if money>=200:
        print('打九点五折,付款金额为:',money*0.95)
    else:
        print('不打折,付款金额为:',money)

对象的布尔值

• Python一切皆对象，所有对象都有一个布尔值
  • 获取对象的布尔值
    • 使用内置函数bool()
• 以下对象的布尔值为False
  • False
  • 数值()
  • None
  • 空字符串
  • 空列表
  • 空元组
  • 空字典
  • 空集合

print('--------------以上对象的布尔值为False----------------')
print(bool(False)) #False
print(bool(0))     #False
print(bool(0.0))   #False
print(bool(None))  #False
print(bool(''))    #False
print(bool(""))
print(bool([]))    #空列表
print(bool(list())) #空列表
print(bool(()))     #空元组
print(bool(tuple()))
print(bool({}))    # 空字典
print(bool(dict()))
print(bool(set())) #空集合


print('-------------------其他对象的布尔值均为True--------------------')
print(bool(18))
print(bool(True))
print(bool('hello world'))

条件表达式

• 条件表达式

  • 条件表达式是if...else的简写

• 语法结构；

  x if 判断条件 else y

• 运算规则:

  如果判断条件的布尔值为True,条件表达式的返回值为x,否则条件表达式的返回值为False

'''从键盘录入两个整数,比较两个整数的大小'''
num_a=int(input('请输入第一个整数:'))
num_b=int(input('请输入第二个整数:'))
# 比较大小
'''if num_a >num_b:
    print(num_a,'大于等于',num_b)
else:
    print(num_a,'小于',num_b)'''
print('需要使用条件表达式:')
print(  str(num_a)+'大于等于'+str(num_b) if num_a>=num_b else str(num_a)+'小于'+str(num_b) )

pass 语句

• pass 语句

  • 语句什么都不做,只是一个占位符，用在语法上需要语句的地方

  • 什么时候使用

    先搭建语法结构,还没想好代码怎么写的时候

  • 哪些语句一起使用

    • if语句的条件执行体
    • for-in语句的循环体
    • 定义函数时的函数体

# pass语句，什么都不做，
answer=input('请输入您是会员吗?')


# 判断是否为会员
if answer=='y':
    pass
else:
    pass

Python 基础篇 (五)

内置函数range()

#range() 的三种创建方式
'''第一种创建方式，只有一个参数(小括号中只给了一个数)'''
r=range(10) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],默认从0开始，默认相差1称为步长
print(r)  #0-10
print(list(r)) #可以查看range对象中的整数序列  ->list是列表的意思

'''第二种创建方式,给了两个参数(小括号中，给了两个数,第一个代表start,第二个代表stop)'''
r=range(1,10) #左闭右开  制定了起始值,从1开始，到10结束(不包含10),默认步长为1
print(list(r)) #[1, 2, 3, 4, 5, 6, 7, 8, 9]

'''第三种创建方式,给了三个参数(小括号中给了三个数)'''
r=range(1,10,2)
print(list(r)) #[1, 3, 5, 7, 9]

'''判定指定的整数 在序列中是否存在 in,not in'''
print(10 in r) #False，10不在当前的r这个整数序列中
print(9 in r) #True

print(10 not in r) #True
print(9 not in r) #False

print(range(1,20,1)) #[1,19]
print(range(1,101,1)) #[1...100]

循环结构

a=1
#判断条件表达式
while a<10:
    # 执行条件执行体
    print(a)
    a+=1

while循环的执行流程

#计算0-4之间的累加和
'''
四步循环法
1. 初始化变量
2. 条件判断
3. 条件执行体(循环体)
4. 改变变量
总结: 初始化变量与条件判断的变量与改变的变量为同一个'''

sum=0 #存储累加
'''初始化变量为0'''
a=0
'''条件判断'''
while a<5:
    '''条件执行体(循环体)'''
    sum+=a;
    '''改变变量'''
    a+=1
print('和为:',sum)

'''计算1到100之间的偶数和'''
sum=0 #用于存储偶数和
'''初始化变量'''
a=1
'''条件判断'''
while a<=100:
    '''条件判断体(求和)'''
    #条件判断是否是偶数
    if not bool(a%2):   # if a%2==0:
        sum+=a
    '''改变变量'''
    a+=1;
print('1-100的偶数和为:',sum)

for-in循环

for item in 'Python':  #第一次取得值为P，将P赋值给item,将item的值输出
    print(item)

#range() 产生一个整数序列 ->>也是一个可迭代对象
for i in range(10):
    print(i)

#如果在循环体中，不需要用到使用自定义变量，可将自定义变量写为"_"
for _ in range(5):
    print('人生苦短，我用Python')

sum=0
print('使用for循环,计算1到100之间的偶数和')
for item in range(1,101):
    if item%2==0:
        sum+=item
print('1-100的偶数和为:',sum)

"""
''' 输出100到999之间的水仙花数
    举例；
    153=3*3*3+5*5*5+1*1*1'''
for item in range(100,1000):
    ge=item%10
    shi=item//10%10
    bai=item//100
    #print(ge,shi,bai)
    #判断
    if ge**3+shi**3+bai**3==item:
        print(item)

流程控制语句break

a=0
while a<3:
    '''条件执行体(循环体)'''
    pwd=input('请输入密码')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')

    ''' 改变变量'''
    a+=1

流程控制语句continue

'''要求输出1-50之间所有5的倍数，5,10,15,20,25....
    5的倍数共同点:和5的余数为0的数都是5的倍数
    什么样的数不是5的倍数  1,2,3,4,6,7,8...
    要求是使用continue实现'''
for item in range(1,51):
    if item%5==0:
        print(item)
print('----------使用continue------------')
for item in range(1,51):
    if item%5!=0:
        continue
    print(item)

else语句

for item in range(3):
    pwd=input('请输入密码:')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码错误')
else:
    print('对不起,三次密码均输入错误')

a=0
while a<3:
    pwd=input('请输入密码')
    if pwd=='8888':
        print('密码正确')
        break
    else:
        print('密码不正确')
    '''改变变量'''
    a+=1
else:
    print('对不起，三次输入密码错误')

嵌套循环

for i in range(1,10):  #行
    for j in range(1,i+1):  #列
        print(i,'*',j,'=',i*j,end='\t')
    print()

二重循环中的break和continue

 ''' 流程控制语句break与continue在二重循环中的使用'''
for i in range(5):  #代表外层循环要执行5次
    for j in range(1,11):
        if j%2==0:
            #break
            continue
        print(j,end='\t')
    print()