简单认识python（一）

最近本宝宝被一部小说迷的神魂颠倒的，在网络上四处找免费的小说资源，一直哭唧唧的等待着每天更新的一章。实在是太可怜了，本宝宝决定自己学python，自己抓包小说。

既然知道目的地了，那就和本宝宝一起打怪，一定要把那部小说拿下拿下，你们有木有信心。

“有”“有”“有”“有”“有”“有”“有”“有”“有”“有”“有”“有”“有”“有”“有”“有”“有”“有”“有”“有”

Python的由来

python的创始人为吉多·范罗苏姆（Guido van Rossum）。1989年的圣诞节期间，Guido开始写Python语言的编译器。Python这个名字，来自Guido所挚爱的电视剧Monty Python’s Flying Circus。他希望这个新的叫做Python的语言，能符合他的理想：创造一种C和shell之间，功能全面，易学易用，可拓展的语言。并且在他去谷歌面试的时候简历只写了一句话，就是我创造了Python,可见能力确实不一般。

Python所涉及领域

1、WEB开发——最火的Python web框架Django, 支持异步高并发的Tornado框架，短小精悍的flask,bottle, Django官方的标语把Django定义为the framework for perfectionist withdeadlines(大意是一个为完全主义者开发的高效率web框架)

2、网络编程——支持高并发的Twisted网络框架， py3引入的asyncio使异步编程变的非常简单

3、爬虫——爬虫领域，Python几乎是霸主地位，Scrapy\Request\BeautifuSoap\urllib等，想爬啥就爬啥

4、云计算——目前最火最知名的云计算框架就是OpenStack,Python现在的火，很大一部分就是因为云计算

5、人工智能——谁会成为AI 和大数据时代的第一开发语言？这本已是一个不需要争论的问题。如果说三年前，Matlab、Scala、R、Java 和 Python还各有机会，局面尚且不清楚，那么三年之后，趋势已经非常明确了，特别是前两天 Facebook 开源了 PyTorch 之后，Python 作为 AI 时代头牌语言的位置基本确立，未来的悬念仅仅是谁能坐稳第二把交椅。

6、自动化运维——问问中国的每个运维人员，运维人员必须会的语言是什么？10个人相信会给你一个相同的答案，它的名字叫Python

金融分析——我个人之前在金融行业，10年的时候，我们公司写的好多分析程序、高频交易软件就是用的Python,到目前,Python是金融分析、量化交易领域里用的最多的语言

科学运算—— 你知道么,97年开始，NASA就在大量使用Python在进行各种复杂的科学运算，随着NumPy, SciPy, Matplotlib, Enthought librarys等众多程序库的开发，使的Python越来越适合于做科学计算、绘制高质量的2D和3D图像。和科学计算领域最流行的商业软件Matlab相比，Python是一门通用的程序设计语言，比Matlab所采用的脚本语言的应用范围更广泛

7、游戏开发——在网络游戏开发中Python也有很多应用。相比Lua or C++,Python 比 Lua 有更高阶的抽象能力，可以用更少的代码描述游戏业务逻辑，与 Lua 相比，Python 更适合作为一种 Host 语言，即程序的入口点是在 Python 那一端会比较好，然后用 C/C++ 在非常必要的时候写一些扩展。Python 非常适合编写 1 万行以上的项目，而且能够很好地把网游项目的规模控制在 10 万行代码以内。另外据我所知，知名的游戏<文明> 就是用Python写的

安装python



验证安装成功



Python文件执行代码步骤

1、先启动Python解释器

2、Python解释器读取python代码文件从硬盘读到内存中

3、再进行解释执行

Python 执行代码的两种方式

1、交互执行即黑屏命令行执行

优点:即时调时程序，调试方便

缺点：无法永久无法保存代码

2、即文件存储代码执行Python代码文件

优点：可以永久保存代码

缺点：调试不方便

第一个应用程序 helloworld[这是未保存的]



第二种方式是在脚本中运行 输入python 文件名称即可

Python注释

分为单行注释：用#来进行注释

#XXXXXX
``

多行注释：三个单引号引起来即

```py
''' XXXXXX '''

Python数据类型

数字类型：

整型数字：用来表示年龄、QQ号等

qq = 8180874

int（整型）

在32位机器上，整数的位数为32位，取值范围为-231～231-1，即-2147483648～2147483647

在64位系统上，整数的位数为64位，取值范围为-263～263-1，即-9223372036854775808～9223372036854775807

long（长整型）

跟C语言不同，Python的长整数没有指定位宽，即：Python没有限制长整数数值的大小，但实际上由于机器内存有限，我们使用的长整数数值不可能无限大。

注意，自从Python2.2起，如果整数发生溢出，Python会自动将整数数据转换为长整数，所以如今在长整数数据后面不加字母L也不会导致严重后果了。

注意：在Python3里不再有long类型了，全都是int

>>> a= 2**64
>>> type(a)  #type()是查看数据类型的方法
<type 'long'>
>>> b = 2**60
>>> type(b)
<type 'int'>

除了int和long之外， 其实还有float浮点型, 复数型，

字符串类型：

引号引起来的：用来表示名字、性别等

name = xiaowei

可分为单行和多行如下：

name = 'lhw'

name = '''

lhw

lhw

'''

列表类型：

可以表示多个值(并且值可以是任意数字类型)如:

hobbies = ['eat','swimming',123]

取列表的值需要用下标进行取值从0开始如：

hobbies[0]

字典类型：

采用key对应value的方式进行存值如下：

user_info = {'name':'xiaowei','age':18}

取值的方式需用key来取如下：

user_info ['name']

注意：key必须是不可变数据类型（不可hash类型），value可以任意数据类型

布尔类型：

即值为True或False

Python字符串拼接

Python字符串拼接只能用加号或乘号，加即拼到一块，乘则是字符串翻倍

字符串的拼接用+号，但最好少用+，因为用加号通常是在内存中新开辟一个空间去存拼接的值，能少用则少用

>>> name
'Alex Li'
>>> age
'22'
>>>
>>> name + age  #相加其实就是简单拼接
'Alex Li22'
>>>
>>> name * 10 #相乘其实就是复制自己多少次，再拼接在一起
'Alex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex LiAlex Li'

Python 格式化输出占位符替换

Python 用有：%s、%d

%s是字符串占位它可以接受数字或字符串

%d 是只可以接收数字

如下：

name = input("Name:")
age = input("Age:")
job = input("Job:")
hobbie = input("Hobbie:")

info = '''
------------ info of %s ----------- #这里的每个%s就是一个占位符，本行的代表 后面拓号里的 name
Name  : %s  #代表 name
Age   : %s  #代表 age
job   : %s  #代表 job
Hobbie: %s  #代表 hobbie
------------- end -----------------
''' %(name,name,age,job,hobbie)  # 这行的 % 号就是 把前面的字符串 与拓号 后面的 变量 关联起来 

print(info)

Python 类型强制转换

 int(x [,base ])         将x转换为一个整数
   long(x [,base ])        将x转换为一个长整数
   float(x )               将x转换到一个浮点数
   complex(real [,imag ])  创建一个复数
   str(x )                 将对象 x 转换为字符串
   repr(x )                将对象 x 转换为表达式字符串
   eval(str )              用来计算在字符串中的有效Python表达式,并返回一个对象
   tuple(s )               将序列 s 转换为一个元组
   list(s )                将序列 s 转换为一个列表
   chr(x )                 将一个整数转换为一个字符
   unichr(x )              将一个整数转换为Unicode字符
   ord(x )                 将一个字符转换为它的整数值
   hex(x )                 将一个整数转换为一个十六进制字符串
   oct(x )                 将一个整数转换为一个八进制字符串

类型转换

convert to int

print('int()默认情况下为：', int())
print('str字符型转换为int：', int('010'))
print('float浮点型转换为int：', int(234.23))
#十进制数10，对应的2进制，8进制，10进制，16进制分别是：1010,12,10,0xa
print('int(\'0xa\', 16) = ', int('0xa', 16))
print('int(\'10\', 10) = ', int('10', 10))
print('int(\'12\', 8) = ', int('12', 8))
print('int(\'1010\', 2) = ', int('1010', 2))

convert to long

print('int浮点型转换为int：', int(23))

convert to float

print('float()默认情况下为：', float())
print('str字符型转换为float：', float('123.01'))
print('int浮点型转换为float：', float(32))

covert to complex

print('创建一个复数(实部+虚部)：', complex(12, 43))
print('创建一个复数(实部+虚部)：', complex(12))

convert to str

print('str()默认情况下为：', str())
print('float字符型转换为str：', str(232.33))
print('int浮点型转换为str：', str(32))
lists = ['a', 'b', 'e', 'c', 'd', 'a']
print('列表list转换为str:', ''.join(lists))

covert to list

strs = 'hongten'
print('序列strs转换为list:', list(strs))

covert to tuple

print('列表list转换为tuple:', tuple(lists))

字符和整数之间的转换

#char coverted to int
print('整数转换为字符chr:', chr(67))
print('字符chr转换为整数:', ord('C'))

print('整数转16进制数:', hex(12))
print('整数转8进制数:', oct(12))

Python 运算符

计算机可以进行的运算有很多种，可不只加减乘除这么简单，运算按种类可分为算数运算、比较运算、逻辑运算、赋值运算、成员运算、身份运算、位运算，今天我们暂只学习算数运算、比较运算、逻辑运算、赋值运算

算数运算以下假设变量：a=10，b=20



比较运算以下假设变量：a=10，b=20



赋值运算以下假设变量：a=10，b=20



逻辑运算



Python 循环终止语句

在Python循环终止语句有三种：

1、break

  break用于退出本层循环

 示例如下：

while True:
    print "123"
    break
    print "456"

2、continue

  continue为退出本次循环，继续下次循环

 示例如下:

while True:
    print "123"
    continue
    print "456"

3、自定义标记 Tag

  自已定义一个标记为True或False

 示例代码：

Tag =  True
while True:
    print "123"
    print "456"
    Tag = False

Python 可变变量与不可变变量

可变变量：也就是ID不变，值可以变，这种类型叫可变变量，如：字典

不可变变量：即值一变id也变，即重新创造一个空间存值，如int、str等

Python 二进制、八进制、十六进制转换函数

二进制：bin()

八进制：oct()

十六进制：hex()

Python 列表的定义以及常用函数

定义：

my_girl_friends=['aa','bb','cc',4,10,30] 或my_girl_friends=list(['aa','bb','cc',4,10,30])

# 获取类型
print(type(my_girl_friends))

#取第几个位置的取
print(my_girl_friends[2])

#取范围第几到第几的值
print(my_girl_friends[1:3])
#
# 追加元素进去
my_girl_friends.append('oldboy')
print(my_girl_friends)

#pop按照默认弹出元素，从右往左弹
my_girl_friends.pop()
my_girl_friends.pop()

#pop按照索引弹出元素
my_girl_friends.pop(0)
my_girl_friends.pop(0)
my_girl_friends.pop(1)

#remove按照值删除无素
my_girl_friends.remove('yuanhao')
print(my_girl_friends)

#得出列表元素个数
my_girl_friends.__len__()
print(len(my_girl_friends))

#元素是否在列表
print('wupeiqi' in my_girl_friends)

my_girl_friends=['a','b','c','d',4,10,30]
#在某个具体位置插入元素
my_girl_friends.insert(1,'Sb')
print(my_girl_friends)

#清空列表
my_girl_friends.clear()
print(my_girl_friends)

#复制列表给别的变量
l=my_girl_friends.copy()
print(l)

#统计元素在列表中的个数
print(my_girl_friends.count('ee'))

#列表追加元素
my_girl_friends.append('a1')
my_girl_friends.append('a2')
my_girl_friends.append('a3')
print(my_girl_friends)

# 列表追加多个元素
my_girl_friends.extend(['oldboy1','oldboy2','oldboy3'])
print(my_girl_friends)

#获取元素在列表中的下标
print(my_girl_friends.index('alex'))

#列表反转
my_girl_friends.reverse()
print(my_girl_friends)

#列表中的值排序
l=[3,-1,5,2]
l.sort(reverse=True)
print(l)

Python 给多个变量同时赋值

#给多个变量赋值
data=['alex',84,[1900,3,38]]
name,age,birth=data
print(name)
print(age)
print(birth)
#
msg='hello'
a,b,c,d,e=msg
print(a,b,c,d,e)

msg='hello'
a,_,_,_,b=msg
print(a)
print(b)
#只给第一个和最后一个变量赋值
a,*_,b=msg
print(a,b)

Python 元组的定义以及常用函数

定义(元组是有序的且值是不可重复的)：

age=(11,22,33,44,55,33) 或 age=tuple((11,22,33,44,55)) 或 name = "a", "b", "c", "d";

#取值
print(age[2])
# 范围取值
print(age[1:4])
# 某个元素个数
print(len(age))
#元素是否在元组中
print(11 in age)

# 取元组的下标
print(age.index(33))

#元组连接
(1, 2, 3) + (4, 5, 6)

# 取某个元素在元组中的个数
print(age.count(33))
#
# 计算元组中最大的元素
max(age)
# 计算元组中最小的元素
min(age)

Python 集合的定义以及常用运算及函数

定义（集合内可以有多个元素，但是每个元素都必须是不可变类型，即可hash类型，集合内的元素唯一，集合是无序的）：

pythons=['a','b','c','d','e','f']
s1=set('hello')
print(s1,type(s1))
s={'a',3,9,'b'}
#关系运算？？？

# print(s)

#集合优先掌握的方法
pythons={'a','b','c','d','e','f'}
#元素是否在集合中
print('a' not in pythons)
print(pythons)

#关系运算
s1={1,10,11,22}
s2={1,11,33}

#交集
print(s1 & s2)

#并集
print(s1 | s2)

#差集
print(s1 - s2)
print(s2 - s1)

#对称差集
print(s1 ^ s2)

#父集
s1={1,2,3,4}
s2={1,5}
print(s1 >= s2)
#
# #子集
print(s1 <= s2)
print(s2 <= s1)

s={1,2,3,'a'}
#集合增加一个元素
s.add(4)
print(s)

#集合取出一个元素
print(s.pop())

#集合删除一个元素如果没有报错
s.remove('a')
print(s)
#
#集合删除一个元素如果没有则不会报错
s.discard('aaaaaa')
print(s)

Python 数据类型的总结

按存值个数区分

标量／原子类型:数字，字符串

容器类型:列表，元组，字典

按可变不可变区分

可变:列表，字典

不可变:数字，字符串，元组

按访问方式区分

直接访问：数字

按照索引访问（序列类型）：字符串，列表，元组

key访问（映射类型） 字典

counter = 100          # 整型变量
miles   = 1000.0       # 浮点型变量
name    = "runoob"     # 字符串

print (counter)
print (miles)
print (name)

Python3 中有六个标准的数据类型：

Number（数字）

String（字符串）

List（列表）

Tuple（元组）

Set（集合）

Dictionary（字典）

Python3 的六个标准数据类型中：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变量[头下标:尾下标]

索引值以 0 为开始值，-1 为从末尾的开始位置。

#!/usr/bin/python3

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']

print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表
与Python字符串不一样的是，列表中的元素是可以改变的：
List 内置了有很多方法，例如 append()、pop() 等等，这在后面会讲到。

注意：

1、List写在方括号之间，元素用逗号隔开。

2、和字符串一样，list可以被索引和切片。

3、List可以使用+操作符进行拼接。

4、List中的元素是可以改变的。

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。

元组中的元素类型也可以不相同：
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')

print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

元组与字符串类似，可以被索引且下标索引从0开始，-1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。

其实，可以把字符串看作一种特殊的元组。

Set（集合）

集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。

基本功能是进行成员关系测试和删除重复元素。

可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,...}

或者

set(value)

Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。

python 读取文件

#打开文件
# f=open('a.txt','r',encoding='utf-8')
# 读取全部
# res=f.read()
# print(res)

#读一行
# print(f.readline(),end='')
# print(f.readline(),end='')
#读多行
# print(f.readlines())
# print(f)
# 关闭文件
# f.close()
Python with open来进行文件操作
#可以进行多个文件同时打开，并且不用关心文件有关闭的问题
# with open('a.txt','r',encoding='utf-8') as f,open('b.txt') as f1:

Python 文件写操作

#文件写模式
f=open('a.txt','w',encoding='utf-8')
#文件写
f.write('11111\n')
f.write('2222\n')
f.write('3333\n4444\n')
#文件写多行
f.writelines(['a\n','b\n','c\n'])
#关闭
f.close()

本文借鉴自https://www.cnblogs.com/liuxiaowei/category/1034666.html

本文学习自http://www.runoob.com/python3/python3-data-type.html

本文学习自慕课网