Python基础（值，变量，运算符）

Python基础（值，变量，运算符）

pycharm操作

运行：ctrl + f10

运行当前文件：ctrl +shift + f10

一、Python中的输出函数

print()函数

• 可以输出数字
• 可以是字符串
• 输出的内容可以是含有运算符的表达式

print()函数可以将内容输出的目的地

• 显示器

• 文件

  #输出到文件中,注意：1，所指定的盘符存在，使用file=fp
  fp = open('D:/text.txt','a+')
  print('hello world',file=fp)
  fp.close()
  

文件不存在就创建，存在就在文件内容后面追加

print()函数的输出形式

• 换行

  • 上面的再执行一次，会在text.txt文件中换行再输入一次hello world

• 不换行

  • #不进行换行输出，
    print('hello','world','python')
    

二，转义字符与原字符

• 什么是转义字符呢？
  • 就是反斜杠+想要实现转义功能首字母
• 为什么需要转义字符？
  • 当字符串中包含反斜杠，单引号和双引号等有特殊用途的字符时，必须使用反斜杠对这些字符进行转义（转换一个含义）
    • 反斜杠 \
    • 单引号 ’
    • 双引号 "
  • 当字符串中包含换行，回车，水平制表符或退格等无法直接表示的特殊字符是，也可以使用转义字符
    • 换行 \n
    • 回车 \r
    • 水平制表符 \t
    • 退格 \b

print('hello \n world')

输出：

hello
world

有换行

print('hello\nworld')
print('hello\tworld')
print('helloooo\tworld')

hello
world
hello world
helloooo world

一个\t 是三个空格，第二个\t是四个空格，因为hello的o已经占了一个位置，一个制表位是四个空格的大小，第二个helloooo刚好8个字符，不占制表位

print('hello\rworld')

输出结果：

world

因为输出hello后 \r 回车，就又回到开头的位置，然后把hello给干掉了

print('hello\bworld')

输出：

hellworld

o没了,因为退格 \b 退没了

print('http:\\\\www.baidu.com')

输出网址：

http:\\www.baidu.com

输出带引号的内容：

print('老师说：\'大家好\'')

输出：

老师说：'大家好'

原字符，不希望字符串中的转义字符起作用，就使用原字符，就是在字符串之前加上r，或R

print(r'hello\nworld')

输出：

hello\nworld

注意事项：最后一个字符不是反斜杠

如：

print(r'hello\nworld\')

会报错

但是，可以是两个

print(r'hello\nworld\\')

输出：

hello\nworld\\

三，二进制及字符编码

推荐使用utf-8

四、Python中的标识符和保留字

规则：

• 字母，数字，下划线
• 不能以数字开头
• 不能是保留字
• 严格区分大小写

查看保留字：

import keyword
print(keyword.kwlist)

输出结果：

[‘False’, ‘None’, ‘True’, ‘peg_parser’, ‘and’, ‘as’, ‘assert’, ‘async’, ‘await’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘nonlocal’, ‘not’, ‘or’, ‘pass’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]

五，变量的定义和使用

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

  name = '奥利给'
  print(name)
  print('标识',id(name))
  print('类型',type(name))
  print('值',name)
  

  输出：

  奥利给
  标识 2122703801680    #内存地址
  类型 <class 'str'>    #类型
  值 奥利给
  

• 变量的多次赋值

  nam = 'men'
  nam = 'chu'
  print(nam)
  

  输出：

  chu
  

  nam 这个变量的指向会从原来的变为指向新的空间

六，Python中常见的数据类型

• 常用的数据类型
  • 整数类型 int 98
  • 浮点数类型 float 3.14159
  • 布尔类型 bool True False （开头大写）
  • 字符串类型 str ‘人生苦短，我用Python’

整数类型

• 可以表示正数，负数，和零

  • n1 = 90
    n2 = -12
    n3 = 0
    print(n1,type(n1))
    print(n2,type(n2))
    print(n3,type(n3))
    

    输出：

    90 <class ‘int’>
    -12 <class ‘int’>
    0 <class ‘int’>

• 整数可以表示为二进制，十进制，八进制，十六进制

  • print('十进制',118)
    print('二进制',0b10110101)  #二进制0b开头
    print('八进制',0o176)      #八进制0o开头    
    print('十六进制',0xEFA)     #十六进制0x开头
    

  输出：

十进制 118
二进制 181
八进制 126
十六进制 3834

浮点类型

• 整数部分和小数部分组成

n4 = 3.14159
print(n4,type(n4))

输出：

3.14159 <class ‘float’>

• 浮点数存储不精确

  n5 = 1.1
  n6 = 2.2
  print(n5 + n6)
  

  输出：

  3.3000000000000003

  这是因为计算机二进制存储导致的，但是也不一定就全会出错

  n5 = 1.1
  n6 = 2.1
  print(n5 + n6)
  n7 = 1.2
  print(n6 + n7)
  

  输出：

  3.2
  3.3

• 解决办法

  • 导入模块decimal

  • from decimal import Decimal
    print(Decimal('1.1') + Decimal('2.2'))
    

    输出：

    3.3

    必须要有引号：

    from decimal import Decimal
    print(Decimal(1.1) + Decimal(2.2))
    

    输出：

    ​ 3.300000000000000266453525910

布尔类型

用来表示真或者假的值

True,False

布尔值可以转化为整数

• True 1
• False 0

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

输出

True <class ‘bool’>
False <class ‘bool’>

转换：

f1 = True
f2 = False
print(f1 + 1)  #1+1 的结果为2，True表示1
print(f2 + 1)  #0+1 的结果为1，False表示0

输出：

2
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))

输出结果：

人生苦短，我用python <class 'str'>
人生苦短，我用python <class 'str'>
人生苦短，
我用python <class 'str'>
人生苦短，
我用python <class 'str'>

只有三个引号的才能多行，而且输出的结果也是多行

类型转换str()函数与int()函数

• str()函数

name = '张三'
age = 20
print(type(name),type(age))
# print('我叫'+name+ '今年'+age+'岁')   #str类型与int类型进行连接时，报错，要类型转换
print('我叫'+name+ '今年'+str(age)+'岁') #str()函数进行了类型转换，转成str类型

<class ‘str’> <class ‘int’>
我叫张三今年20岁

• 其他类型转换成str类型

  a = 10
  b = 198.8
  c = False
  print(str(a),str(b),str(c))
  

  输出：

  10 198.8 False

  转换之后的类型

print(str(a),str(b),str(c),type(str(a)), type(str(b)), type(str(c)))

输出：

10 198.8 False <class ‘str’> <class ‘str’> <class ‘str’>

可见已经类型变了

• int()函数

s1 = '128'
f1 = 98.7
s2 = '78.77'
ff = True
s3 = 'hello'
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))) #将布尔值转为int,True 变为1，False 对应为0
# print(int(s3),type(int(s3))) #将str转为int报错，字符串必须为数字，并且为整数

输出：

128 <class ‘int’>
98 <class ‘int’>
1 <class ‘int’>

类型转换_float()函数

s1 = '128.98'
s2 = '76'
ff = True
fb = False
s3 = 'hello'
i = 98
print(float(s1),type(float(s1)))
print(float(s2),type(float(s2)))
print(float(ff),type(float(ff)))  #转成了float类型，True对应1.0
print(float(fb),type(float(fb)))  #转成了float类型，False对应0.0
# print(float(s3),type(float(s3)))  #报错，不是数字字符串
print(float(i),type(float(i)))   #转成了float类型，并且加了个小数部分

输出：

128.98 <class 'float'>
76.0 <class 'float'>
1.0 <class 'float'>
0.0 <class 'float'>
98.0 <class 'float'>

int float str 互相之间可以有条件转换，函数 int() str() float()

python中的注释

单行注释 # 开头，直到换行结束

多行注释 一对三引号之间的代码 （三个单引号和三个双引号都可以）

中文编码声明注释：在文件开头加上中文声明注释，用以指定源码文件的编码格式

​ 如何操作：新建个python文件，文件开头第一行，不空格，加上

#coding:gbk

也可以是utf-8

然后就知道这是注释文件了，用记事本打开，另存时发现格式是ANSI

六，python中的输入函数input()

作用：接收来自用户的输入

返回值类型：输入值的类型为str

值的存储：使用=对输入的值进行存储

a = input('请输入一个加数：')
b = input('请输入另一个加数：')
print(a + b)

输出：

请输入一个加数：10
请输入另一个加数：20
1020

证明输入的类型变str了，然后成了拼接字符串

• 类型转换

  • 如果需要整数型和浮点型，就需要将str类型通过int()函数或者float()函数进行类型转换

    例子：

    a = int(input('请输入一个加数：'))
    b = int(input('请输入另一个加数：'))
    print(a + b)
    

    输出：

    请输入一个加数：10
    请输入另一个加数：20
    30
    

    这样就可以既输出，又获取输出结果转换然后操作了

七，运算符

常用运算符：算术运算符（标准算术运算符，取余运算符，幂运算符），赋值运算符，比较运算符，布尔运算符，位运算符

算术运算符

• 加法运算

  • print(1 + 1) # 加法运算
    

    输出：

    2

• 减法运算

  • print(2 - 1) # 减法运算
    

    输出：

    1

• 乘法运算

  • print(2*4)   # 乘法运算
    

    输出：

    8

• 除法运算

  • print(2/4)   # 除法运算
    

    输出

    0.5

• 整除运算

  • print(11//2)   #取商，整除运算
    

    输出：

    5

• 取余运算

  • print(11%2)   #取余运算
    

    输出：

    1

• 幂运算

  • print(2**3) #幂运算
    

    输出：

    8 即：求2的3次幂

• 整除的特殊情况

  • print(-9//4)
    print(9//-4)
    print(17//-4)
    print(11//2)
    

    输出：

    -3
    -3
    -5
    5

    原因：一正一负，向下取整

• 取余数特殊情况

  • print(9%-4)   #公式：余数=被除数-除数*商  9-(-4)*(-3) = -3
    print(17%-4)
    

    输出：

    -3
    -3

    这里的商应该是整除的商

赋值运算符

=

执行顺序：右 到左

支持链式赋值 ： a=b=c=20

支持参数赋值： += -= *= /= //= %=

支持系列解包赋值：a,b,c=20,30,40

a=b=c=20
print(a)
print(b)
print(c)

输出：

20
20
20

链式赋值本质，多个变量同时指向一个空间

a = 2
b = 3
a **= b
print(a)

输出：8

a,b,c = 20,30,40
print(a)
print(b)
print(c)

d,e,f=6,'egg',3.14159
print(d)
print(e)
print(f)

输出：

20
30
40
6
egg
3.14159

注意：左右变量个数和值的个数要一致

print("----------交换两个变量的值--------")
a,b=10,20
print('交换之前：',a,b)
#交换
a,b=b,a
print('交换之后：',a,b)

输出：

交换之前： 10 20
交换之后： 20 10

注意：作用，不用第三个变量中转，实现值的交换，可以对比其他语言

比较运算符

• 对变量或表达式的结果进行大小、真假等比较

• 类型

• >,<,>=,<=,!=
  ==  #对象value的比较
  is, is not   #对象的id的比较
  

print('---------比较运算符----------')
a,b=10,20
print('a>b吗？',a>b)
print('a<b吗？',a<b)
print('a>=b吗？',a>=b)
print('a<=b吗？',a<=b)
print('a==b吗？',a==b)
print('a!=b吗？',a!=b)

输出：

---------比较运算符----------
a>b吗？ False
a<b吗？ True
a>=b吗？ False
a<=b吗？ True
a==b吗？ False
a!=b吗？ True

注意：

一个 = 称为赋值运算符， == 称为比较运算符

一个变量由三部分组成，标识，类型，值

== 比较的是值，比较标识用 is, is not

特殊情况：

a = 10
b = 10
print(a==b)
print(a is b )
print(a is not b)

list1=[11,22,33,44]
list2=[11,22,33,44]
print(list1==list2)
print(list1 is list2)
print(list1 is not list2)

输出：

True
True
False
True
False
True

证明：当是数字时，实际上a,b 都指向了同一个空间的id

而list类型则不会

布尔运算符

• 对于布尔值之间的运算

and   or   not   in   not in   

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

输出：

True
False
False
False

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

输出：

True
True
True
False

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

输出：

-----not 对bool类型操作数取反----
False
True

print('-----in 与 not in --------')
s = 'helloworld'
print('w' in s)
print('k' in s)
print('w' not in s)
print('k' not in s)

输出：

-----in 与 not in --------
True
False
False
True

列表等待研究

位运算符

位与&  对应数位都是1，结果数位才是1，否则为0
位或 | 对应数位都是0，结果数位才是0，否则为1
左移位运算符<<  高位溢出舍弃，低位补0
右移位运算符>>  低位溢出舍弃，高位补0

运算符优先级

第一： **

第二： *，/,//,%  

第三：+，-

以上为算术运算符，优先级第一

第四： <<  >>

第五：&

第六: |

位运算符优先级第二梯队

第七： >,<,>=,<=,==,!=

比较运算符第三梯队

第八：and

第九：or

第四梯队：布尔运算符

最后：=  赋值运算符