关于python: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
    <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 字符串运算符

【实例】字符串运算符操作：

    #!/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 字符串格式化符号:

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