Python 3 教程（3）

958

在 Windows 下可以不写第一行注释:
```
#!/usr/bin/python3
```
第一行注释标的是指向 python 的路径，告诉操作系统执行这个脚本的时候，调用 /usr/bin 下的 python 解释器。

此外还有以下形式（推荐写法）：
```
#!/usr/bin/env python3
```
这种用法先在 env（环境变量）设置里查找 python 的安装路径，再调用对应路径下的解释器程序完成操作。
淡然感世
淡然感世

107***5530@qq.com
7年前 (2017-04-09)

荆棘乱

llc***n@gmail.com

550

关于注释，也可以使用 ''' ''' 的格式在三引号之间书写较长的注释；

''' ''' 还可以用于在函数的首部对函数进行一个说明：

def example(anything):
    '''形参为任意类型的对象，
       这个示例函数会将其原样返回。
    '''
    return anything

help() 函数

调用 python 的 help() 函数可以打印输出一个函数的文档字符串：

# 如下实例，查看 max 内置函数的参数列表和规范的文档
>>> help(max)
……显示帮助信息……

按下 : q 两个按键即退出说明文档

如果仅仅想得到文档字符串：

>>> print(max.__doc__)    # 注意，doc的前后分别是两个下划线
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value

With a single iterable argument, return its biggest item. The
default keyword-only argument specifies an object to return if
the provided iterable is empty.
With two or more arguments, return the largest argument.

荆棘乱

llc***n@gmail.com

7年前 (2017-05-05)

杨叔儿

231***9699@qq.com

429

在 print 打印的时候双引号与单引号都可以当做定界符使用，且可以嵌套。

被嵌套的会被解释成为标点符号，反之一样。

代码实例：
```
print("Hello'World!")
```
这句代码执行时，外侧的双引号为定界符，里面的那个单引号为标点符号。

输出：
```
Hello'World!
```
```
print('Hello"World!')
```
这句代码执行时，外侧的单引号为定界符，里面的那个双引号为标点符号。

输出：
```
Hello"World!
```
杨叔儿
杨叔儿

231***9699@qq.com
6年前 (2018-05-16)

Python初学者

pan***4@126.com

347

要善用 help() 方法

通过命令 help("print") 我们知道这个方法里第三个为缺省参数 sep=' '。

这里表示我们使用分隔符为一个空格。

>>> help("print")
Help on built-in function print in module builtins:
print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

所以在打印 dict 类的使用, 可以这样写:

>>> def getPairs(dict):
...     for k,v in dict.items() :
...             print(k,v,sep=':')
...

测试代码:

>>> getPairs({ x : x ** 3 for x in (1,2,3,4)})
1:1
2:8
3:27
4:64
>>>

Python初学者

pan***4@126.com

5年前 (2018-11-23)

   落落

  102***4053@qq.com

   参考地址

217

“Windows 命令行窗口”下清屏，可用下面两种方法。

第一种方法，在命令行窗口输入：
```
>>> import os
>>> i=os.system("cls")
```
第二种方法，在命令行窗口输入：
```
>>> import subprocess
>>> i=subprocess.call("cls", shell=True)
```
落落
   落落

  102***4053@qq.com

   参考地址
5年前 (2019-03-22)
   yester

  zha***u07j@163.com

635

关于 import 的小结，以 time 模块为例：

1、将整个模块导入，例如：import time，在引用时格式为：time.sleep(1)。

2、将整个模块中全部函数导入，例如：from time import *，在引用时格式为：sleep(1)。

3、将模块中特定函数导入，例如：from time import sleep，在引用时格式为：sleep(1)。

4、将模块换个别名，例如：import time as abc，在引用时格式为：abc.sleep(1)。
yester
   yester

  zha***u07j@163.com
5年前 (2019-04-19)
兔子脚

syf***61127@163.com

909

当字符串内容为浮点型要转换为整型时，无法直接用 int() 转换：
```
a='2.1'  # 这是一个字符串
print(int(a))
```
会报错 "invalid literal for int() "。

需要把字符串先转化成 float 型再转换成 int 型：
```
a='2.1'
print(int(float(a)))
```
输出 2。
兔子脚
兔子脚

syf***61127@163.com
5年前 (2019-08-12)
xvpi

904***172@qq.com

168

类似于 C/C++ 的 printf，Python 的 print 也能实现格式化输出，方法是使用 % 操作符，它会将左边的字符串当做格式字符串，将右边的参数代入格式字符串：
```
print("100 + 200 = %d" % 300) #左边的%d被替换成右边的300
print("A的小写是%s" % "a") #左边的%s被替换成右边的a
```
得到的结果是：
```
100 + 200 = 300A的小写是a
```
如果要带入多个参数，则需要用 () 包裹代入的多个参数，参数与参数之间用逗号隔开，参数的顺序应该对应格式字符串中的顺序：
```
print("%d + %d = %d" % (100,200,300))
print("%s %s" % ("world","hello"))
```
得到的结果是：
```
100 + 200 = 300world hello
```
格式字符串中，不同占位符的含义：
- %s：作为字符串
- %d：作为有符号十进制整数
- %u：作为无符号十进制整数
- %o：作为无符号八进制整数
- %x：作为无符号十六进制整数，a～f采用小写形式
- %X：作为无符号十六进制整数，A～F采用大写形式
- %f：作为浮点数
- %e，%E：作为浮点数，使用科学计数法
- %g，%G：作为浮点数，使用最低有效数位
xvpi
xvpi

904***172@qq.com
1年前 (2022-12-19)

521

元组（小拓展）

一般来说，函数的返回值一般为一个。

而函数返回多个值的时候，是以元组的方式返回的。

示例（命令行下）：
```
>>>def example(a,b):
...     return (a,b)
...
>>>type(example(3,4))
<class 'tuple'>
>>>
```
python中的函数还可以接收可变长参数，比如以 "*" 开头的的参数名，会将所有的参数收集到一个元组上。

例如：
```
def test(*args):
    print(args)
    return args

print(type(test(1,2,3,4)))    #可以看见其函数的返回值是一个元组
```
字典（小拓展）

python中的字典是使用了一个称为散列表（hashtable）的算法（不具体展开），

其特点就是：不管字典中有多少项，in操作符花费的时间都差不多。

如果把一个字典对象作为for的迭代对象，那么这个操作将会遍历字典的键：
```
def example(d):
    # d 是一个字典对象
    for c in d:
        print(c)
        #如果调用函数试试的话，会发现函数会将d的所有键打印出来;
        #也就是遍历的是d的键，而不是值.
```
荆棘乱
荆棘乱

llc***n@gmail.com
7年前 (2017-05-05)
我去咬你啦

815***114@qq.com

297

针对楼上的字典拓展，做测试的时候，想要输出 kye:value的组合发现可以这样：
```
for c in dict:
    print(c,':',dict[c])
```
或者
```
for c in dict:
    print(c,end=':');
    print(dict[c])
```
于是发现 print()函数其实可以添加多个参数，用逗号隔开。

本来想要用
```
for c in dict:
    print(c+':');
    print(dict[c])
```
这样的方式打印 key：value结果发现其实 key不一定是 string类型，所以用+ 号会出问题。
我去咬你啦
我去咬你啦

815***114@qq.com
7年前 (2017-06-28)

愤怒的胸毛毛

zha***aijun2013@foxmail.com

199

在list的使用中，开始时很容易忽视的一点是：

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
print (list[1:3])       # 从第二个开始输出到第三个元素

list[1:3] 其实输出的只有两个变量，即list中第二个元素到第三个元素，并不是第1 第2 第3三个元素，而且要注意的是

print (list[2])
print (list[2:3])

这两句话打印的内容其实是一样的，

2.23
[2.23]

但是第二句话有中括号

------------------------------------------------------

以下是网友 temmple_wang@qq.com 的补充：

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
print (list[1:3])       # 从第二个开始输出到第三个元素
# 获得结果 [786, 2.23]

其实我觉得可以这样理解：

print (list[1:3])       # 从数组下标为1的数开始获取直到数组下标为3（但不包含3）的数为止，输出这段
# 获得结果 [786, 2.23]

其实我们可以试验一下：

print (list[1:0])       # 没有输出的值
# 获得结果 []

print (list[1:1])       # 没有输出的值
# 获得结果 []

print (list[0:1])       # 没有输出的值
# 获得结果 ['abcd']

其实中括号里的值还可以为负数：

>>> print(arrtest[1:-1])    # 从下标为1的数开始，输出到下标为4但不包含4的所有值
[786, 2.23, 'runoob']
>>> print(arrtest[-3:-2])   # 从下标为2的数开始，输出到下标为3但不包含3的所有值
[2.23]

----------------------------

list 补充:

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
print (list[2])
print (list[2:3])

这两句话打印的内容其实是一样的:

2.23
[2.23]

但注意是不同的类型，用变量接收一下：

a = list[2]
b = list[2:3]
type(a) -> <class 'float'>
type(b) -> <class 'list'>

愤怒的胸毛毛

zha***aijun2013@foxmail.com

7年前 (2017-07-02)

hellowqp

wqp***a@foxmail.com

102

python 与 C 语言和 Java 语言的一点不同，表现在它的变量不需要声明变量类型，这是因为像 C 语言和 Java 语言来说，它们是静态的，而 python 是动态的，变量的类型由赋予它的值来决定，例如：
```
>>> a = 1
>>> a = 1.001
>>> a = "python"
>>> print(a)
python
>>> 
```
第一次为变量 a 赋值为整型，第二次赋值是浮点数，第三次是一个字符串，最后输出时只保留了最后一次的赋值。
hellowqp
hellowqp

wqp***a@foxmail.com
7年前 (2017-07-08)
   燕春

  zqs***306010@qq.com

   参考地址

86

type 是用于求一个未知数据类型对象，而 isinstance 是用于判断一个对象是否是已知类型。

type 不认为子类是父类的一种类型，而isinstance会认为子类是父类的一种类型。

可以用 isinstance 判断子类对象是否继承于父类，type 不行。

综合以上几点，type 与 isinstance 虽然都与数据类型相关，但两者其实用法不同，type 主要用于判断未知数据类型，isinstance 主要用于判断 A 类是否继承于 B 类：
```
# 判断子类对象是否继承于父类
class father(object):
    pass
class son(father):
    pass
if __name__ == '__main__':
    print (type(son())==father)
    print (isinstance(son(),father))
    print (type(son()))
    print (type(son))
```
运行结果：
```
False
True
<class '__main__.son'>
<type 'type'>
```
燕春
   燕春

  zqs***306010@qq.com

   参考地址
7年前 (2017-09-15)
妞妞

704***556@qq.com

140

字典（小拓展）

输入 dict 的键值对，可直接用 items() 函数：
```
dict1 = {'abc':1,"cde":2,"d":4,"c":567,"d":"key1"}
for k,v in dict1.items():
    print(k,":",v)
```
妞妞
妞妞

704***556@qq.com
6年前 (2017-12-07)

hjc132

huj***heng132@gmail.com

172

字典（小拓展）

原文说 dict(d)创建一个字典。d 必须是一个序列 (key,value)元组。

其实d不一定必须为一个序列元组，如下：

>>> dict_1 = dict([('a',1),('b',2),('c',3)]) #元素为元组的列表
>>> dict_1
{'a': 1, 'b': 2, 'c': 3}
>>> dict_2 = dict({('a',1),('b',2),('c',3)})#元素为元组的集合
>>> dict_2
{'b': 2, 'c': 3, 'a': 1}
>>> dict_3 = dict([['a',1],['b',2],['c',3]])#元素为列表的列表
>>> dict_3
{'a': 1, 'b': 2, 'c': 3}
>>> dict_4 = dict((('a',1),('b',2),('c',3)))#元素为元组的元组
>>> dict_4
{'a': 1, 'b': 2, 'c': 3}

hjc132

huj***heng132@gmail.com

6年前 (2017-12-10)

   好好学习天天向上

  522***154@qq.com

71

集合与字典

无序：集合是无序的，所以不支持索引；字典同样也是无序的，但由于其元素是由键（key）和值（value）两个属性组成的键值对，可以通过键（key）来进行索引

元素唯一性：集合是无重复元素的序列，会自动去除重复元素；字典因为其key唯一性，所以也不会出现相同元素
好好学习天天向上
   好好学习天天向上

  522***154@qq.com
6年前 (2018-03-01)

Lonapse

270***302@qq.com

参考地址

#coding=utf8  
''''' 
复数是由一个实数和一个虚数组合构成，表示为：x+yj 
一个负数时一对有序浮点数(x,y)，其中x是实数部分，y是虚数部分。 
Python语言中有关负数的概念： 
1、虚数不能单独存在，它们总是和一个值为0.0的实数部分一起构成一个复数 
2、复数由实数部分和虚数部分构成 
3、表示虚数的语法：real+imagej 
4、实数部分和虚数部分都是浮点数 
5、虚数部分必须有后缀j或J 
 
复数的内建属性： 
复数对象拥有数据属性，分别为该复数的实部和虚部。 
复数还拥有conjugate方法，调用它可以返回该复数的共轭复数对象。 
复数属性：real(复数的实部)、imag(复数的虚部)、conjugate()（返回复数的共轭复数） 
'''  
class Complex(object):  
    '''''创建一个静态属性用来记录类版本号'''  
    version=1.0  
    '''''创建个复数类，用于操作和初始化复数'''  
    def __init__(self,rel=15,img=15j):  
        self.realPart=rel  
        self.imagPart=img  
         
    #创建复数  
    def creatComplex(self):  
        return self.realPart+self.imagPart  
    #获取输入数字部分的虚部  
    def getImg(self):  
        #把虚部转换成字符串  
        img=str(self.imagPart)  
        #对字符串进行切片操作获取数字部分  
        img=img[:-1]   
        return float(img)    
                         
def test():  
    print "run test..........."  
    com=Complex()  
    Cplex= com.creatComplex()  
    if Cplex.imag==com.getImg():  
        print com.getImg()  
    else:  
        pass  
    if Cplex.real==com.realPart:  
        print com.realPart  
    else:  
        pass  
    #原复数  
    print "the religion complex is :",Cplex  
    #求取共轭复数  
    print "the conjugate complex is :",Cplex.conjugate()  
      
if __name__=="__main__":  
    test()

Lonapse

270***302@qq.com

参考地址

6年前 (2018-03-11)

符号

974***897@QQ.com

切片还可以设置步长

demo = [1,2,3,4,5,6]

new_demo = demo[1::2]  # 2 就是步长 意思是从索引为 1 的元素开始 每隔2个元素取一次元素
new_demo = [2,4,6] 

# 以索引为列  [索引] 和 [索引:索引:步长] 的区别
# demo[索引] 取出的原列表中索引对应的元素
# demo[索引:索引:步长] 切片得到的是一个新列表

符号

974***897@QQ.com

6年前 (2018-06-06)

   王二的弟弟

  182***56065@163.com

   参考地址

54

bool 型

Python 中布尔值使用常量 True 和 False 来表示。

1、在数值上下文环境中，True 被当作 1，False 被当作 0，例如：
```
>>> True+3
4
>>> False+2
2
```
2、其他类型值转换 bool 值时除了 ''、""、''''''、""""""、0、()、[]、{}、None、0.0、0L、0.0+0.0j、False 为 False 外，其他都为 True 例如：
```
>>> bool(-2)
True
>>> bool('')
False
```
王二的弟弟
   王二的弟弟

  182***56065@163.com

   参考地址
6年前 (2018-07-25)

健子

136***9943@qq.com

对应一楼，函数的参数为多个时，不一定是以元组的形式返回的，还是要看自己定义的返回形式是什么:

>>> def example(a,b):
...     return (a,b)
... 
>>> type(example(3,4))
<type 'tuple'>
>>> def example(a,b):
...     return a,b
... 
>>> type(example(3,4))
<type 'tuple'>
>>> def example(a,b):
...     return [a,b]
... 
>>> type(example(3,4))
<type 'list'>

健子

136***9943@qq.com

5年前 (2018-12-25)

went000

751***610@qq.com

105

针对楼上对一楼的观点提出的不同意见，但是一楼实际说的是返回值有多个时，而非楼上说的参数为多个。
```
>>> type(example(3,4))
<type 'tuple'>
>>> def example(a,b):
...     return [a,b]
... 
>>> type(example(3,4))
<type 'list'>
```
以上实际返回值也只有一个，一个 List 类型的参数。

一楼所说的返回值为多个是：
```
>>> type(example(3,4))
<type 'tuple'>
>>> def example(a,b):
...     return a,b
... 
>>> type(example(3,4))
<type 'tuple'>
```
went000
went000

751***610@qq.com
5年前 (2019-01-18)
flaray

144***3921@qq.com

34

Bool 型小知识 :
- Python2 支持：int、float、long、complex（复数）
- Python3 支持：int、float、bool、complex（复数）
Python3 废除了 long 类型，将 0 和 1 独立出来组成判断对错的 Bool 型，即 0 和 1 可以用来判断 flase 和 true。但是根本上并没有修改原则。这里的 Bool 型依然是 int 型的一部分，所以依然能当做数字参与运算，所以 Python3 里的 Bool 型是 int 型的一个特例而不是一个独立的类型。
flaray
flaray

144***3921@qq.com
5年前 (2019-03-06)

甄能忽悠呀

813***866@qq.com

注意：列表、元组、集合有所区别(新人特别容易入坑)。

列表和元组不会把相同的值合并，但是集合会把相同的合并。

>>> clist = ['tom','tom','jerry']                #测试列表功能
>>> print (clist）
['tom','tom','jerry']

>>>ctuple = ('tom','tom','jerry')           #测试元组功能
>>>print(ctuple)
('tom','tom','jerry') 

>>>cset = {'tom','tom','jerry'}                #测试集合功能
>>>print(cset)
{'tom','jerry'}

甄能忽悠呀

813***866@qq.com

5年前 (2019-04-11)

dianmouren

yan***i4242@outlook.com

39

关于列表的创建细节补充：
```
>>> o = {1, 2, 3}
>>> type(o)
<class 'set'>
>>> o = {}
>>> type(o)
<class 'dict'>
```
dianmouren
dianmouren

yan***i4242@outlook.com
4年前 (2019-10-05)

紫竹修韵

162***3732@qq.com

参考地址

关于字典推导式的一些案例：

'''

# 字典推导式
p = {i:str(i) for i in range(1,5)}
print("p:",p)
'''
p: {1: '1', 2: '2', 3: '3', 4: '4'}
'''

x = ['A','B','C','D']
y = ['a','b','c','d']
n = {i:j for i,j in zip(x,y)}
print("n:",n)
'''
n: {'A': 'a', 'B': 'b', 'C': 'c', 'D': 'd'}
'''

s = {x:x.strip() for x in ('he','she','I')}
print("s:",s)
'''
s: {'he': 'he', 'she': 'she', 'I': 'I'}
'''

紫竹修韵

162***3732@qq.com

参考地址

4年前 (2020-01-29)

   Creepercdn

  cre***rcdn@outlook.com

51

所有数据类型都是类。

也就是说，int、str等数据类型不是函数，只是一个类罢了。

用int()、str()、list()等都是初始化相应的类，那么123456、"Runoob“、[1,2,3] 等都是相应数据类型的初始化结果。

有很多人和教学网站都认为int、str、list等数据类型都是函数，但这是错误的。type(int)的输出结果表明int是一个类。
Creepercdn
   Creepercdn

  cre***rcdn@outlook.com
4年前 (2020-08-03)
闫伟超

yif***chaoran@163.com

88

此处延伸下变量和对象之间的关系：
- 赋值操作，本质是创建引用
- 变量是变量，对象是对象，当将某个对象赋值给某个变量时，可以认为是创建了变量对该对象的引用
- 变量没有数据类型之说，只有对象有，即变量不是直接代表对象或对象占用的内存空间
- Python中，变量无需提前声明，无需指定其数据类型，其表现完全是动态的，其所为的数据类型决定于当前该变量所引用的对象的数据类型
- 所谓变量对对象的引用，本质是创建了变量指向对象内存空间的指针
- 对象内存空间，一般最起码有类型和当前被引用次数这两个信息，类型记录了该对象的数据类型，被引用次数记录了该对象内存空间被变量引用的次数
- 当某对象的被引用次数为0时，Python便会自动回收该对象内存空间
比如下面的
```
a=10
a='122'
a=[1,2,3]
del a
```
此时，a在不同的赋值代码行中，引用的对象类型不同，相当于在不断改变a引用的对象，最后当把a变量删除时，其实本质只是删除了a变量名，但由于a引用的[1,2,3]对象，因为a被删除，其被引用次数变为0，也就自动被Python回收，最终表现就是del a时，[1,2,3]也被删除了。

另外一个小知识是，Python为提升代码执行和内存分配效率，会对一些常用的对象提前创建好，并常驻内存，比如下面：
```
id(4) #不管运行多少次该代码，其返回的值均不变，因为python会保持一些常用的数字常驻内存，不会每次都重新分配内存空间
id('hello world') #每次运行，返回的值均会发生变化，因为每次运行，相当于都在重新分配内存空间
```
闫伟超
闫伟超

yif***chaoran@163.com
3年前 (2021-02-20)
   elliotalderson

  274***2424@qq.com

29

type的意思可以理解为：检查这个变量本身的类型，而不用管他的父类的类型

isinstance的意思可以理解为：判断这个变量的类型是不是属于某一个大类，就好像找家谱一样，判断你是不是这个家族的人

is用来不仅会对比数值是否一样，还会对比类型是否相同，并且是不是对比父类类型
elliotalderson
   elliotalderson

  274***2424@qq.com
2年前 (2022-01-16)

Python3 数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，一般情况下你只需要将数据类型作为函数名即可。

Python 数据类型转换可以分为两种：

隐式类型转换 - 自动完成
显式类型转换 - 需要使用类型函数来转换

隐式类型转换

在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预。

以下实例中，我们对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。

实例

num_int = 123
num_flo = 1.23

num_new = num_int + num_flo

print("num_int 数据类型为:",type(num_int))
print("num_flo 数据类型为:",type(num_flo))

print("num_new 值为:",num_new)
print("num_new 数据类型为:",type(num_new))

以上实例输出结果为：

num_int 数据类型为: <class 'int'>
num_flo 数据类型为: <class 'float'>
num_new: 值为: 124.23
num_new 数据类型为: <class 'float'>

代码解析：

实例中我们对两个不同数据类型的变量 num_int 和 num_flo 进行相加运算，并存储在变量 num_new 中。
然后查看三个变量的数据类型。
在输出结果中，我们看到 num_int 是 整型（integer） ， num_flo 是 浮点型（float）。
同样，新的变量 num_new 是 浮点型（float），这是因为 Python 会将较小的数据类型转换为较大的数据类型，以避免数据丢失。

我们再看一个实例，整型数据与字符串类型的数据进行相加：

实例

num_int = 123
num_str = "456"

print("num_int 数据类型为:",type(num_int))
print("num_str 数据类型为:",type(num_str))

print(num_int+num_str)

以上实例输出结果为：

num_int 数据类型为: <class 'int'>
num_str 数据类型为: <class 'str'>
Traceback (most recent call last):
  File "/runoob-test/test.py", line 7, in <module>
    print(num_int+num_str)
TypeError: unsupported operand type(s) for +: 'int' and 'str'

从输出中可以看出，整型和字符串类型运算结果会报错，输出 TypeError。 Python 在这种情况下无法使用隐式转换。

但是，Python 为这些类型的情况提供了一种解决方案，称为显式转换。

显式类型转换

在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。我们使用 int()、float()、str() 等预定义函数来执行显式类型转换。

int() 强制转换为整型：

实例

x = int(1) # x 输出结果为 1
y = int(2.8) # y 输出结果为 2
z = int("3") # z 输出结果为 3

float() 强制转换为浮点型：

实例

x = float(1)     # x 输出结果为 1.0
y = float(2.8)   # y 输出结果为 2.8
z = float("3")   # z 输出结果为 3.0
w = float("4.2") # w 输出结果为 4.2

str() 强制转换为字符串类型：

实例

x = str("s1") # x 输出结果为 's1'
y = str(2) # y 输出结果为 '2'
z = str(3.0) # z 输出结果为 '3.0'

整型和字符串类型进行运算，就可以用强制类型转换来完成：

实例

num_int = 123
num_str = "456"

print("num_int 数据类型为:",type(num_int))
print("类型转换前，num_str 数据类型为:",type(num_str))

num_str = int(num_str) # 强制转换为整型
print("类型转换后，num_str 数据类型为:",type(num_str))

num_sum = num_int + num_str

print("num_int 与 num_str 相加结果为:",num_sum)
print("sum 数据类型为:",type(num_sum))

以上实例输出结果为：

num_int 数据类型为: <class 'int'>
类型转换前，num_str 数据类型为: <class 'str'>
类型转换后，num_str 数据类型为: <class 'int'>
num_int 与 num_str 相加结果为: 579
sum 数据类型为: <class 'int'>

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

函数	描述
int(x [,base])	将x转换为一个整数
float(x)	将x转换到一个浮点数
complex(real [,imag])	创建一个复数
str(x)	将对象 x 转换为字符串
repr(x)	将对象 x 转换为表达式字符串
eval(str)	用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)	将序列 s 转换为一个元组
list(s)	将序列 s 转换为一个列表
set(s)	转换为可变集合
dict(d)	创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s)	转换为不可变集合
chr(x)	将一个整数转换为一个字符
ord(x)	将一个字符转换为它的整数值
hex(x)	将一个整数转换为一个十六进制字符串
oct(x)	将一个整数转换为一个八进制字符串

数据类型的高低之分：

"较高数据类型"和"较低数据类型"是在隐式类型转换中用于描述数据精度的概念。精度可以理解为数据类型能够表示的信息量或详细程度。在Python中，数据类型的"高"和"低"主要根据它们的精度来判断。

这里的"较高"数据类型指的是能够表示更多信息（或更精确信息）的数据类型，而"较低"的数据类型则表示的信息较少。具体来说，比如浮点数就比整数"高"，因为浮点数不仅可以表示整数，还可以表示小数。所以在你的例子中，整数就会被自动转换为浮点数，以保证信息不丢失。

再比如，复数（complex）就比浮点数（float）和整数（int）"高"，因为复数可以表示实数和虚数，而浮点数和整数只能表示实数。所以在进行运算时，如果操作数包含复数，那么其他的浮点数或整数就会被转换为复数。

通常情况下，Python的数据类型的"高低"可以按照如下顺序理解：布尔（bool）< 整型（int） < 浮点型（float）< 复数（complex）。这个顺序主要根据数据类型可以表示的信息范围和精度来确定的。

不同数据类型之间能否随意转化：

虽然Python提供了一些内置的函数来实现不同数据类型之间的转换，如int(), float(), str(), list(), tuple(), set()等等，但并非所有类型的数据都可以被转换成其他任意类型。转换是否可行，主要取决于数据本身是否包含足够的信息来表示目标类型。

例如：

你可以轻松地将整数转换为字符串，因为每一个整数都有一个明确的字符串表示（例如，整数123可以表示为字符串"123"）。
类似地，一个只包含数字字符的字符串（如"123"）可以被转换为一个整数或浮点数，因为这个字符串中包含了足够的信息来表示一个数字。

然而：

对于一个非数字字符串（如"Hello"），它无法被转换为一个整数或浮点数，因为这个字符串并不包含任何可以表示一个数字的信息。
对于一个列表或元组，它可以被转换为一个集合（如果它的元素是不可变的），但不能被转换为一个整数，因为一个集合或列表中的元素无法合理地表示为一个单独的数字。

总的来说，数据类型的转换并非无限制，它取决于原始数据是否能够提供足够的信息来表示目标类型。当你在编程中进行类型转换时，需要注意这一点。

Python3 解释器

Linux/Unix的系统上，一般默认的 python 版本为 2.x，我们可以将 python3.x 安装在 /usr/local/python3 目录中。

安装完成后，我们可以将路径 /usr/local/python3/bin 添加到您的 Linux/Unix 操作系统的环境变量中，这样您就可以通过 shell 终端输入下面的命令来启动 Python3 。

$ PATH=$PATH:/usr/local/python3/bin/python3    # 设置环境变量
$ python3 --version
Python 3.4.0

在Window系统下你可以通过以下命令来设置Python的环境变量，假设你的Python安装在 C:\Python34 下:

set path=%path%;C:\python34

交互式编程

我们可以在命令提示符中输入"Python"命令来启动Python解释器：

$ python3

执行以上命令后，出现如下窗口信息：

$ python3
Python 3.4.0 (default, Apr 11 2014, 13:05:11) 
[GCC 4.8.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

在 python 提示符中输入以下语句，然后按回车键查看运行效果：

print ("Hello, Python!");

以上命令执行结果如下：

Hello, Python!

当键入一个多行结构时，续行是必须的。我们可以看下如下 if 语句：

>>> flag = True
>>> if flag :
...     print("flag 条件为 True!")
... 
flag 条件为 True!

脚本式编程

将如下代码拷贝至 hello.py文件中：

print ("Hello, Python!");

通过以下命令执行该脚本：

python3 hello.py

输出结果为：

Hello, Python!

在Linux/Unix系统中，你可以在脚本顶部添加以下命令让Python脚本可以像SHELL脚本一样可直接执行：

#! /usr/bin/env python3

然后修改脚本权限，使其有执行权限，命令如下：

$ chmod +x hello.py

执行以下命令：

./hello.py

输出结果为：

Hello, Python!

814

Python 解释器可不止一种哦，有 CPython、IPython、Jython、PyPy 等。

顾名思义，CPython 就是用 C 语言开发的了，是官方标准实现，拥有良好的生态，所以应用也就最为广泛了。

而 IPython 是在 CPython 的基础之上在交互式方面得到增强的解释器（Jupyter and the future of IPython — IPython）。

Jython 是专为 Java 平台设计的 Python 解释器（Home | Jython），它把 Python 代码编译成 Java 字节码执行。

PyPy 是 Python 语言（2.7.13和3.5.3）的一种快速、兼容的替代实现（PyPy），以速度快著称。
chendu
chendu

987***757@qq.com
6年前 (2018-05-15)
   爱奇奇

  767***953@qq.com

   参考地址

1023

$ python test.py 运行失败

在 cmd 窗口输入 $ python test.py，得到运行错误的提示：
- Python 的实际工作场景往往是 Unix 或者 Linux。而代码开头的 $ 表示 UNIX 或 Mac OS 操作系统命令提示符。$的意思就是 “提示用户输入命令行”，$ 本身不在输入的命令语句中。$ 是不需要输入的。
- Python 的编程模式分为两种：交互式，脚本式。
- 交互式编程，需要我们打开 cmd 窗口（命令提示符窗口），在窗口中键入python,回车，这样就进入了交互式编程。此时我们直接输入 python 语句，就可以得到运行的结果：
- 脚本式编程，就是我们先把 python 语句写好，保存在后缀为 .py 的文件里，然后从外部调用这个文件。它也可以使用 cmd 窗口进行调用，与交互式编程不同的是，不要在cmd窗口内输入python加回车来进入交互模式
- 如果我们要在cmd窗口调用test.py文件，只需要将cmd路径目录转入test.py所在的文件夹，然后输入命令即可
- 假设我们的test.py文件放在D盘，路径为：D:\Python27\Mytest\test.py 那么要在cmd窗口调用这个文件，我们需要将目录路径切换到D:\Python27\Mytest。使用cd命令即可做到。
以下是简单的补充：
cmd 窗口打开方式：右键开始菜单，选择‘命令提示符（管理员）’即可。或者从开始菜单->运行->输入cmd，回车。
关于 cd 命令：用于改变当前目录路径。使用方式：cd[空格][路径]
例如 cd d:/Python27/Mytest 转到该路径下
注意：如果当前盘符不是 D 盘，需要先转到 D 盘，输入 d: 回车即可。然后才可以使用 cd d:/Python27/Mytest

爱奇奇
   爱奇奇

  767***953@qq.com

   参考地址
5年前 (2018-11-25)