python语言复数类型实部不可以为0_Python学习笔记Day2 - Python变量

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

8888888888888888888888

-7777777777777777777777

整数的不同进制

在 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:

f2Value: 0.34557808421257

f2Type:

f3Value: 8.47e-26

f3Type:

f4Value: 3.456797451324568e+26

f4Type:

f5Value: 120000.0

f5Type:

f6Value: 1.2300000000000002

f6Type:

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

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)语言