1. Python 变量的定义和应用
变量的赋值
Python 应用等号=
作为赋值运算符,具体格局为: name = value
变量的值不是变化无穷的,它能够随时被批改,只有从新赋值即可;另外你也不必关怀数据的类型,能够将不同类型的数据赋值给同一个变量。请看上面的演示:
n = 10 #将 10 赋值给变量 n
n = 95 #将 95 赋值给变量 n
n = 200 #将 200 赋值给变量 n
abc = 12.5 #将小数赋值给变量 abc
abc = 85 #将整数赋值给变量 abc
abc = "http://c.biancheng.net/" #将字符串赋值给变量 abc
除了赋值单个数据,你也能够将表达式的运行后果赋值给变量,例如:
sum = 100 + 20 #将加法的后果赋值给变量
rem = 25 * 30 % 7 #将余数赋值给变量
str = "Hello +"Python" #将字符串拼接的后果赋值给变量
留神,变量的值一旦被批改,之前的值就被笼罩了,不复存在了,再也找不回了
2. 规范数据类型
在内存中存储的数据能够有多种类型。
Python 有五个规范的数据类型:
Numbers(数字)String(字符串)List(列表)Tuple(元组)Dictionary(字典)Bool(布尔)
3. Python 整数类型(int)
Python 的整数不分类型,当所用数值超过计算机本身的计算能力时,Python 会主动转用高精度计算(大数计算)
#将 78 赋值给变量 n
n = 78
print(n)
print(type(n) )
#给 x 赋值一个很大的整数
x = 8888888888888888888888
print(x)
print(type(x) )
#给 y 赋值一个很小的整数
y = -7777777777777777777777
print(y)
print(type(y) )
运行后果:
78
<class 'int'>
8888888888888888888888
<class 'int'>
-7777777777777777777777
<class 'int'>
整数的不同进制
在 Python 中,能够应用多种进制来示意整数:
- 十进制模式
咱们平时常见的整数就是十进制模式,它由 0~9 共十个数字排列组合而成。
- 二进制模式
由 0 和 1 两个数字组成,书写时以 0b 或 0B 结尾。例如,101 对应十进制数是 5。
- 八进制模式
八进制整数由 0~7 共八个数字组成,以 0o 或 0O 结尾。留神,第一个符号是数字 0,第二个符号是大写或小写的字母 O。
- 十六进制模式
由 0~9 十个数字以及 A~F(或 a~f)六个字母组成,书写时以 0x 或 0X 结尾
【实例】不同进制整数在 Python 中的应用:
#十六进制
hex1 = 0x45
hex2 = 0x4Af
print("hex1Value:", hex1)
print("hex2Value:", hex2)
#二进制
bin1 = 0b101
print('bin1Value:', bin1)
bin2 = 0B110
print('bin2Value:', bin2)
#八进制
oct1 = 0o26
print('oct1Value:', oct1)
oct2 = 0O41
print('oct2Value:', oct2)
运行后果:
hex1Value: 69
hex2Value: 1199
bin1Value: 5
bin2Value: 6
oct1Value: 22
oct2Value: 33
数字分隔符
为了进步数字的的可读性,Python 3.x 容许应用下划线_作为数字(包含整数和小数)的分隔符。
【实例】应用下划线书写数字:
click = 1_301_547
distance = 384_000_000
print("Python 教程浏览量:", click)
print("地球和月球的间隔:", distance)
运行后果:
Python 教程浏览量:1301547
地球和月球的间隔:384000000
4. Python 小数 / 浮点数(float)类型
Python 中的小数有两种书写模式:
- 十进制模式
这种就是咱们平时看到的小数模式,例如 34.6、346.0、0.346。
- 指数模式
Python 小数的指数模式的写法为:aEn 或 aen
a 为尾数局部,是一个十进制数;
n 为指数局部,是一个十进制整数;
E 或 e 是固定的字符,用于宰割尾数局部和指数局部。
整个表达式等价于 a×10n。
指数模式的小数举例:
- 2.1E5 = 2.1×105,其中 2.1 是尾数,5 是指数。
- 3.7E-2 = 3.7×10-2,其中 3.7 是尾数,-2 是指数。
- 0.5E7 = 0.5×107,其中 0.5 是尾数,7 是指数。
Python 只有一种小数类型,就是 float
【实例】小数在 Python 中的应用:
f1 = 12.5
print("f1Value:", f1)
print("f1Type:", type(f1))
f2 = 0.34557808421257003
print("f2Value:", f2)
print("f2Type:", type(f2))
f3 = 0.0000000000000000000000000847
print("f3Value:", f3)
print("f3Type:", type(f3))
f4 = 345679745132456787324523453.45006
print("f4Value:", f4)
print("f4Type:", type(f4))
f5 = 12e4
print("f5Value:", f5)
print("f5Type:", type(f5))
f6 = 12.3 * 0.1
print("f6Value:", f6)
print("f6Type:", type(f6))
运行后果:
f1Value: 12.5
f1Type: <class 'float'>
f2Value: 0.34557808421257
f2Type: <class 'float'>
f3Value: 8.47e-26
f3Type: <class 'float'>
f4Value: 3.456797451324568e+26
f4Type: <class 'float'>
f5Value: 120000.0
f5Type: <class 'float'>
f6Value: 1.2300000000000002
f6Type: <class 'float'>
5. Python 复数类型(complex)
复数由实部(real)和虚部(imag)形成,在 Python 中,复数的虚部以 j 或者 J 作为后缀,具体格局为:a + bj
: a 示意实部,b 示意虚部
【实例】Python 复数的应用:
c1 = 12 + 0.2j
print("c1Value:", c1)
print("c1Type", type(c1))
c2 = 6 - 1.2j
print("c2Value:", c2)
#对复数进行简略计算
print("c1+c2:", c1+c2)
print("c1*c2:", c1*c2)
运行后果:
c1Value: (12+0.2j)
c1Type <class 'complex'>
c2Value: (6-1.2j)
c1+c2: (18-1j)
c1*c2: (72.24-13.2j)
6. Python 字符串(string)
Python 中的字符串必须由 双引号 ”” 或者 单引号 ’ ‘ 突围,具体格局为:
"字符串内容"
'字符串内容'
解决字符串中蕴含引号,咱们有两种解决计划:
- 对引号进行本义
在引号后面增加反斜杠就能够对引号进行本义,让 Python 把它作为一般文本看待,例如:
str1 = 'I\'m a great coder!'str2 =" 引文双引号是 \",中文双引号是“"
print(str1)
print(str2)
- 应用不同的引号突围字符串
str1 = “I’m a great coder!” #应用双引号突围含有单引号的字符串
str2 = ‘ 引文双引号是 ”,中文双引号是“’ #应用单引号突围含有双引号的字符串
print(str1)
print(str2)
运行后果:
I'm a great coder!
引文双引号是 ",中文双引号是“
原始字符串:在一般字符串或者长字符串的结尾加上 r
前缀,就变成了原始字符串
str1 = r'I\'m a great coder!'
print(str1)
输入后果:I\'m a great coder!
应用字符串:
#!/usr/bin/python3
var1 = 'Hello World!'
var2 = "Runoob"
print ("var1[0]:", var1[0])
print ("var2[1:5]:", var2[1:5])
运行后果:
var1[0]: H
var2[1:5]: unoo
Python 字符串运算符
操作符 | 形容 | 实例 |
---|---|---|
+ | 字符串连贯 | a + b 输入后果:HelloPython |
* | 反复输入字符串 | a*2 输入后果:HelloHello |
[] | 通过索引获取字符串中字符 | a[1] 输入后果 e |
[:] | 截取字符串中的一部分,遵循左闭右开准则,str[0:2] 是不蕴含第 3 个字符的。 | a[1:4] 输入后果 ell |
in | 成员运算符 – 如果字符串中蕴含给定的字符返回 True | ‘H’ in a 输入后果 True |
not in | 成员运算符 – 如果字符串中不蕴含给定的字符返回 True | ‘M’ not in a 输入后果 True |
r/R | 原始字符串 – 原始字符串:所有的字符串都是间接依照字面的意思来应用,没有本义非凡或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母 r(能够大小写)以外,与一般字符串有着简直完全相同的语法。 | print(r’n’) 或 print(R’n’) |
% | 格局字符串 | 见下方详细描述 |
【实例】字符串运算符操作:
#!/usr/bin/python3
a = "Hello"
b = "Python"
print("a + b 输入后果:", a + b)
print("a * 2 输入后果:", a * 2)
print("a[1] 输入后果:", a[1])
print("a[1:4] 输入后果:", a[1:4])
if("H" in a) :
print("H 在变量 a 中")
else :
print("H 不在变量 a 中")
if("M" not in a) :
print("M 不在变量 a 中")
else :
print("M 在变量 a 中")
print (r'\n')
print (R'\n')
输入后果:
a + b 输入后果:HelloPython
a * 2 输入后果:HelloHello
a[1] 输入后果:e
a[1:4] 输入后果:ell
H 在变量 a 中
M 不在变量 a 中
\n
\n
Python 字符串格式化
#!/usr/bin/python3
print ("我叫 %s 往年 %d 岁!" % ('小明', 10))
python 字符串格式化符号:
符 号 | 形容 |
---|---|
%c | 格式化字符及其 ASCII 码 |
%s | 格式化字符串 |
%d | 格式化整数 |
%u | 格式化无符号整型 |
%o | 格式化无符号八进制数 |
%x | 格式化无符号十六进制数 |
%X | 格式化无符号十六进制数(大写) |
%f | 格式化浮点数字,可指定小数点后的精度 |
%e | 用迷信计数法格式化浮点数 |
%E | 作用同 %e,用迷信计数法格式化浮点数 |
%g | %f 和 %e 的简写 |
%G | %f 和 %E 的简写 |
%p | 用十六进制数格式化变量的地址 |
Python format 格式化函数
Python2.6 开始,新增了一种格式化字符串的函数 str.format()
,它加强了字符串格式化的性能。
根本语法是通过 {} 和 : 来代替以前的 %。
format 函数能够承受不限个参数,地位能够不按程序。
占位符格式化:
>>>"{} {}".format("hello", "world") # 不设置指定地位,按默认程序
'hello world'
>>> "{0} {1}".format("hello", "world") # 设置指定地位
'hello world'
>>> "{1} {0} {1}".format("hello", "world") # 设置指定地位
'world hello world'
指定参数格式化:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
print("网站名:{name}, 地址 {url}".format(name="菜鸟教程", url="www.runoob.com"))
# 通过字典设置参数
site = {"name": "菜鸟教程", "url": "www.runoob.com"}
print("网站名:{name}, 地址 {url}".format(**site))
# 通过列表索引设置参数
my_list = ['菜鸟教程', 'www.runoob.com']
print("网站名:{0[0]}, 地址 {0[1]}".format(my_list)) # "0" 是必须的
也能够向 str.format() 传入对象:
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class AssignValue(object):
def __init__(self, value):
self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value)) # "0" 是可选的
7. Python bool 布尔类型
- 在程序世界里称之为真(对),Python 应用
True
来代表; -
在程序世界里称之为假(错),Python 应用
False
来代表。5>3
True
4>20
False
8. Python input()函数:获取用户输出的字符串
input()
是 Python 的内置函数,用于从控制台读取用户输出的内容。input()
函数总是以字符串的模式来解决用户输出的内容,所以用户输出的内容能够蕴含任何字符。
input() 函数 的用法为:str = input(tipmsg)
阐明:
- str 示意一个字符串类型的变量,input 会将读取到的字符串放入 str 中。
- tipmsg 示意提示信息,它会显示在管制台上,通知用户应该输出什么样的内容;如果不写 tipmsg,就不会有任何提示信息。
【实例】input() 函数的简略应用:
a = input("Enter a number:")
b = input("Enter another number:")
print("aType:", type(a))
print("bType:", type(b))
result = a + b
print("resultValue:", result)
print("resultType:", type(result))
如果通过输出数值实现科学计算,咱们能够应用 Python 内置函数将字符串转换成想要的类型,比方:
int(string)
将字符串转换成 int 类型;float(string)
将字符串转换成 float 类型;bool(string)
将字符串转换成 bool 类型。
附:Python 是强类型还是弱类型?
动态类型 vs 动静 编程语言
强类型 vs 弱类型 编程语言
- 类型查看
类型查看是一个验证和施加类型束缚的过程,编译器或解释器通常在编译或运行阶段做类型查看。例如,你不能拿一个 string 类型值除以浮点数。
用更简略的术语,类型查看仅仅就是查看变量和它们的类型,而后说这个表达式是正当的。
因而,当初咱们晓得类型查看是什么,明确这些术语真的很简略。
在动态类型语言 (statically typed languages) 中,类型查看产生在编译阶段 (compile time),然而,在动静类型语言(dynamically typed languages) 中,类型查看产生在运行阶段(run time)
- 它意味着什么?
- 类型申明
动态类型 (static): 所有的变量类型必须被显示地申明,因为这些信息在编译阶段就被须要。
例如,在 Java 中 float f = 0.5
动静 (Dynamic): 显示申明不被要求,因为类型赋值产生在运行阶段。
例如在 Python 中,f = 0.5
- 性能
动态类型 (static): 编译阶段做更多解决,然而运行时(run-time) 性能更好
动静(Dynamic): 编译阶段更高效,然而运行时的类型查看会影响到性能
- 灵活性和出错
动态类型: 运行时出错机会更小,然而提供给程序员的灵活性不好
动静类型: 提供更多的灵活性然而运行时出错机会绝对更大
- 什么是强类型 / 弱类型?
首先看下什么是强类型。在强类型中,不论在编译时还是运行时,一旦某个类型赋值给某个变量,它会持有这个类型,并且不能同其余类型在计算某个表达式时混合计算。
例如在 Python 中:data = 5
在 runtime 时,被赋值为整形data = data + "xiaoming"
会报错
然而,在弱类型中,它是很容易与其余类型混合计算的,比方同样一门平凡的语言 Javascript,应用它:var data = 5data = data + 'xiaoming'
,string 和 int 能够联合
- 论断
类型查看确保一个表达式中的变量类型是非法的。
在动态类型语言中,类型查看产生在编译阶段;
在动静类型语言中,类型查看产生在运行阶段。强类型语言有更强的类型查看机制,表达式计算中会做严格的类型查看;
而弱类型语言容许各种变量类型间做一些运算。
Python 是一门动静的 (dynamic) 且强类型 (strong) 语言