python学习笔记本基础知识

目录

1. python3新特性
2. python安装
3. 变量
4. 字符编码
5. 用户输入
6. 模块简介
7. .pyc是什么
8. 数据类型初识
9. 数据运算
10. 表达式
11. 字典
12. 集合set

内容

一、python3 新特性

1、 print

python2	python3
print	print()

2、使用unicode

3、模块改名

python2	python3
_winreg	winreg
ConfigParser	configparser
copy_reg	copyreg
Queue	queue
socketServer	socketserver
markupbase	_markupbase
repr	reprlib
test.test_support	test.support

二、python安装

1、下载安装包
https://www.python.org/downloads/

2、配置环境变量
【右键计算机】–》【属性】–》【高级系统设置】–》【高级】–》【环境变量】–》【在第二个内容框中找到 变量名为Path 的一行，双击】 –> 【Python安装目录追加到变值值中，用 ； 分割】

三、变量

1、生命变量
username = “Jack Wang”
上述代码声明了一个变量，变量名为：name，变量name的值为”Jack Wang”
2、变量定义的规则

• 变量名只能是 字母、数字或下划线的任意组合
• 变量名的第一个字符不能是数字
• 以下关键字不能声明为变量名
  [‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’, ‘exec’, ‘finally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘not’, ‘or’, ‘pass’, ‘print’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]
  3、变量的赋值
  name = “Jack Wang”
  name2 = name
  print(name,name2)
  name = “Jack”
  print(“What is the value of name2 now?”)

四、字符编码

python解释器在加载.py文件中代码时，会对内容进行编码（默认ascill）
ASCII是基于拉丁字母的一套电脑编码系统，主要用于实现英语和其他西欧语言，其最多只能用8位来标识（一个字节），即：2**8 = 256 -1，所以ASCII码最多只能标识255字符。
Unicode（统一码、万国码、单一码）是一种在计算机上使用的字符编码。是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，规定虽然有的字符和符号最少由16位来标识。
UTF-8，是对Unicode编码的压缩和优化，他不再使用最少使用2个字节，而是将所有的字符和符号进行分类，ascill码中的内容用1字节保存，欧洲的字符用2个字节保存，东亚的字符用3个字节保存。。
python解释器在加载.py文件中的代码时，会对内容进行编码（默认ascill），ascii码无法表示中，所以应该告诉python解释器，用什么编码来执行源代码。

#!/usr/bin/env python
# _*_ coding: utf-8 _*_

五、用户输入

1、input 、raw_input

#!/usr/bin/env python 
#_*_coding:utf-8_*_

#python2.x 使用raw_input
name = raw_input("What is your name?") 

#python3.x 使用input
name = input("What is your name?")
print("Hello " + name）

2、getpass模块
输入密码时，如果想要密码不可见，需要利用getpass模块中的getpass方法

import getpass
password = getpass.getpass('请输入密码：')

六、模块简介

1、sys

• sys.argv
  把执行脚本时传递的参数获取到

import sys
print(sys.argv)

输出
$ python test.py helo world
[‘test.py’, ‘helo’, ‘world’]

• sys.path
  打印环境变量，python查找模块顺序是安装环境变量中的目录顺序进行查找的

import sys
print(sys.path)

输出：
[”, ‘/usr/local/lib/python36.zip’, ‘/usr/local/lib/python3.6’, ‘/usr/local/lib/python3.6/lib-dynload’, ‘/usr/local/lib/python3.6/sit
e-packages’]

2、os
操作系统调用模块

• os.system()
• os.mkdir()
• ………
  保存命令的输入结果
  os.popen(“df -h”).read()
  popen()方法将输出结果保存到内存
  read()方法将内存中的内容读取出来

七、.pyc是什么

1、解释性语言和编译型语言

计算机是不能够识别高级语言的，所以当我们运行一个高级语言程序的时候，就需要一个翻译机来从事把高级语言转变成计算机能读懂的机器语言的过程。这个过程分成两种，第一种是编译，第二种是解释。
编译型语言在程序执行之前，先回通过编译器对程序执行一个编译的过程，把程序转变成机器语言。运行时就不需要翻译，而直接执行就可以了。最经典的例子是c语言。
解释性语言就没有这个编译的过程，而是在程序运行的时候，通过解释器对程序逐行做出解释，然后直接运行，最经典的例子就是ruby。
解释型语言和编译型语言的优缺点：因为编译型语言在程序运行之前就已经对程序做出了翻译，所以在运行时就少掉了翻译的过程，所以效率比较高。但是我们也不能一概而论，一些解释性语言也可以通过解释器的优化来对程序做出翻译时对整个程序作出优化，从而在效率上超过编译型语言。
java首先通过编译器编译成字节码文件，然后在运行时通过解释器给解释成机器文件。所以我们说java是一种先编译后解释的语言。

2、python到底是什么

其实python和java、C#一样，也是一门基于虚拟机的语言。
当我们在命令中输入python hello.py时，其实时激活了python的解释器，告诉解释器你要开始工作了。可是在解释之前，其实执行的第一项工作和java一样，是编译。

3、python的运行过程

PyCodeObject和pyc文件
我们在硬盘上看到的pyc自然不用多说，而其实PyCodeObject则是python编译器真正编译成的结果。
当python程序运行时，首先程序会在硬盘中寻找pyc文件，如果找到，则直接载入，否则就重复上面的过程。
pyc文件其实是PyCodeObject的一种持久化保存方式。
手动执行程序的时候是不会生成pyc文件的，只有被引用的模块会生成pyc缓存文件，被导入的模块被认为是不经常修改的并经常被调用的，所以被生成pyc文件。

八、数据类型初识

1、 数字

整数、长整数、浮点数、复数等

• int（整形）

在32位的机器上整数的位数是32位，取值范围-2**31~2**31，即-2147483648～2147483647
在64位的机器上整数的位数是64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807

• long（长整型）

python的长整型没有指定位宽，即python没有限制长整数数值的大小，但是实际上由于机器内存有限，我们使用的长整数数值不可能无限大。
ps : 在python3没有长整型

• float（浮点型）

  浮点数用来处理实数，即带有小数的数字。

• complex（复数）

复数由实数部分和虚数部分组成。

2、布尔值

真或假
1 或 0
在python中通过 True 或 False来定义

3、字符串

‘hello world’
PS：python中的字符串在C语言中体现为是一个字符数组，每次创建字符串时候需要在内存中开辟一块连续的空，并且一旦需要修改字符串的话，就需要再次开辟空间，万恶的+好每出现一次，就会在内存中重新开辟一块空间。

4、字符串格式化输出

name = 'jack'
print('my name is %s,and you ?' %(name))

类型	备注
%s	字符串
%d	整数
%f	浮点数

字符串常用功能

• 移除空白

# 移除两边空格
name.strip()

# 移除左边空格
name.lstrip()

# 移除右边空格
name.rstrip()

# 移除所有空格
naem.replace(' ','')

• 分割（split）

# 拆分字符串
name =  'name1,name2,name3'
# 分割后a是列表
a = name.split(',')
print(a)
输出结果：
['name1', 'name2', 'name3']

• 合并字符串（join）

#'|'.join(a)  合并a列表中的字符串，并用竖线分割
name =  'name1,name2,name3'
a = name.split(',')
print('|'.join(a))
输出结果：
name1|name2|name3

• 增强字符串格式化（format）

# 使用'{}'占位符  
msg = 'Hello , {name} ,it’s been a long {age} since last time sopke...'
msg2 = msg.format(name='Xiao Ming',age='38')
print(msg2 )
输出结果：
Hello , Xiao Ming ,it’s been a long 38 since last time sopke...

# 也可以使用'{0}','{1}'形式的占位符
msg3 = 'haha{0},dddd{1}'
print(msg3 .format('test','0'))
输出结果：
hahatest,dddd0

# 混合使用'{0}','{name}'形式 
print('{0},I\'m {1},{message}'.format('Hello','Hongten',message = 'This is a test message!')) 
输出结果：
Hello,I'm Hongten,This is a test message!

• 长度
• center函数

name = 'wang'
# 输出一个长度40的字符串，将name值居中，两边用横线补充
print(name.center(40,'-'))
输出结果：
----------------wang-----------------

• 查找（find）

# find函数返回的是查找到的第一个元素所在的位置（下标），返回-1代表没有找到
name = 'wang'
print(name.find('l'))

• 字符串判断
  age.isdigit() 判断字符串是否是数字

函数	功能
isdigit()	判断字符串是否是数字
isalpha()	判断字符串是否是字符串
isalpha()	判断字符串是否是字符串
isalnum()	判断字符串是否是字符串数字组成
endswith()	判断字符串以什么结尾
startswith()	判断字符串以什么开始

• 大小写转换 upper lower

# 字符串转大写
print(name.upper())
# 字符串转小写
print(name.lower())

• 切片

name = 'alex li '
print(name[0:4])
输出结果
alex

• 首字符大写

name = 'wang '
# 首字符大写
print(name.capitalize())
输出结果：
Wang

5、列表

创建列表
name_list = [‘name1’,’name2’,’name3’]
name_list = list([‘name1’,’name2’,’name3’])
基本操作

• 索引(index)
  列表中正向取值从name_list[0]开始
  列表中从尾部取值 name_list[-1]开始

# 列表中查找元素的索引，index方法只会返回第一个被查找到的元素所在的位置
name_list.index('name4')

#在列表中将所有name4替换成9999999
for i in range(name_list.count('name4')):
    a = name_list.index('name4')
    name_list[a] = 9999999

• 切片

name_list = ['name1','name2','name3','name4','name5','name6','name7','name8']
#取前两个
print(name_list[:2])
# 取最后3个
print(name_list[-3:])
# 取第2个到第6个
print(name_list[1:6])
# 二次切片，先取第2个到底6个，在取第2个到第3个
print(name_list[1:6][1:3])
# 二次切片，先取第2个到底6个，在取第2个到第3个,再取第1个
print(name_list[1:6][1:3][0])
# 二次切片，先取第2个到底6个，在取第2个到第3个,再取第1个,再取第3个字符
print(name_list[1:6][1:3][0][2])

• 修改

#将列表中第二个元素修改成jack
name_list[1]  = 'Jack'

#删除制定下标对应的元素，不制定默认删除最后一个元素
name_list.pop(3)

• 插入( insert )

#在列表中第三个位置后边插入wang，一次只能插入一个元素
name_list.insert(2,'wang')

• 追加(append)

#在列表中追加Tom
name_list.append('Tom')

• 删除(remove)

#在列表中删除name4，一次删除1个
name_list.remove('name4')
#删除列表中多个元素，del是python的全局功能可以删除任何东西
del name[2:5]

• 长度

print(name_list.__len__())

• 循环

# i从0开始自增长，v取对应列表中元素的值
for i,v in enumerate(name):
    print(i,'----------',v)
# 第二种循环方式
for i in range(len(name)):
    print(i,'----------',name[i])

• 包含

#判断name1是否包含在列表中
'name1' in name

• 统计数量(count)

# 统计name4在列表中的个数
name_list.count('name4')

• 步长

#从第一个元素开始，将每隔一个打印一个
print(name[0::2])

• 清空列表（clear）

name_list.clear

• 扩展列表（extend）

name_list=['name1', 'name2', 'name3', 'name4', 'name4', 'name6', 'name7', 'name8']
name_list2=['张三', '李四','name4']
# 将name_list2追加到name_list列表中
name_list.extend(name_list2)

• 反转列表（reverse）

name_list2.reverse()

输出结果：
['张三', '李四', 'name4']
['name4', '李四', '张三']

• 排序（sort）

# python3中不能对数字和字母同时存在的列表进行排序
name_list.sort()

• 复制（copy）

#渐层复制
#如果name_list中还存在列表，那么当name_list中的子列表修改了，name_list3中的子列表也同时修改。copy()方法只复制列表中的第一层，不会复制第二层。

name_list3=name_list.copy()

#深层复制
#将内存中name_list中所有的数据拷贝到name_list3中，之后name_list中的子列表修改name_list3中子列表数据不会发生变化
import copy
name_list3 = copy.deecopy(name_list)

6、元组（tuple）
元组又称为不可变列表生成之后不可修改

• 定义元组

r = (1,2,3,4,5)

• 统计（count）

r.count()

• 查看索引（index）
  r = (1,2,3,4,5)
  print(r.index(3))

九、数据运算

1、算数运算：

2、比较运算：

3、赋值运算：

4、逻辑运算：
：

5、成员运算：

6、位运算：

7、运算符优先级：

十、表达式

1、if … else 判断

name = input('请输入用户名：')
password = input("请输入密码：")

if name == 'lwm' and password == 'haha':
    print('登录成功')
else:
    print('您的用户名或密码输入有误')

2、for loop 循环

# 循环10次
for i in range(10):
    print("loop:",i)

3、while loop 循环

# 死循环
count=0
while True:
    count+=1
    print(count)

十一、字典

字典是一种key-value的数据类型，使用就像我们上学用的字典，通过笔画、字母查对应页的详细内容。
1、声明一个字典类型数据

# 声明一个字典类型数据
id_db = {
    11 : {
        'name':'wangxiaolei',
        'age':'18',
        'job':'yunwei'
    },
    22 :{
        'name':'sunshangxiang',
        'age':'22',
        'job':'wuye'
    },
    33: {
        'name': 'zhangxiaoming',
        'age': '23',
        'job': 'kaifa'
    }
}

2、字典的特性：

• dict是无序的
• key必须是唯一的

3、字典常用操作

• 取值

id_db[22]
或
id_db.get(22)

• 添加新的值

id_db[22]['name']='huahua'
print(id_db[22]) 
  # 没有add所以直接添加
id_db[22]['add']='add'
print(id_db[22]) 
  # 输出结果:
 {'job': 'wuye', 'age': '22', 'name': 'huahua'}
{'add': 'add', 'job': 'wuye', 'age': '22', 'name': 'huahua'}

• 删除del 或 pop方法

del id_db[22]['add']
或
id_db[22].pop('name')

• 清空 （clear）
• 复制（copy 浅复制）
• 更新（update）

# 用一个列表去更新另外一个列表
id_db = {
    11 : {
        'name':'wangxiaolei',
        'age':'18',
        'job':'yunwei'
    },
    22 :{
        'name':'sunshangxiang',
        'age':'22',
        'job':'wuye'
    },
    33: {
        'name': 'zhangxiaoming',
        'age': '23',
        'job': 'kaifa'
    }
}
dict2 = {
    33: {
        'name': '我是谁',
        'age': '33',
        'job': 'kaifa'
    },
    44: {
        'name': '你们',
        'age': '33',
        'job': '开发'
    }
}
id_db.update(dict2 )
print(id_db)
 # 输出结果:
{
 33: {
     'job': 'kaifa',
     'age': '33', 
     'name': '我是谁' 
     },
 11: {
     'job': 'yunwei',
     'age': '18', 
     'name': 'wangxiaolei'
     }, 
 44: {
     'job': '开发',
     'age': '33', 
     'name': '你们'
     }, 
 22: { 
     'job': 'wuye',
     'age': '22', 
     'name': 'sunshangxiang'
     }
}

• items（）方法
  将字典转换成一个元组

• values（）方法
  将字典中所有值打印出来

• keys()方法
  将字典中所有keys值打印出来
  setdefault（）方法
  判断一个值是否在字典中存在，如果存在则返回keys对应的value，如果不存在返回指定的值

dict2 = {
    33: {
        'name': '我是谁',
        'age': '33',
        'job': 'kaifa'
    },
    44: {
        'name': '你们',
        'age': '33',
        'job': '开发'
    }
}
print(dict2.setdefault(33,333))
print(dict2.setdefault(22,333))
#  输出值
{'age': '33', 'name': '我是谁', 'job': 'kaifa'}
333

• fromkeys（）

#  将列表中的每一个值当做字典中的keys，values在第二个参数中指定
print(dict2.fromkeys([22,33,44,4],'ddd'))
{33: 'ddd', 44: 'ddd', 22: 'ddd', 4: 'ddd'}

• popitem()方法

#  随机删除字典中一个元素，并返回删除的元素
print(id_db.popitem())
print(id_db)

• 循环取出列表中的值

# 方式一
# 效率低下，因为要有一个dict 转 list的转换过程
for k,v in id_db.items():
    print(k,v)

# 方式二
for key in id_db:
    print(key,id_db[key])

十二、集合

集合是一个无序的，不重复的数据组合，它的主要作用如下：

• 去重，把一个列表变成集合，就自动去重了
• 关系测试，测试两组数据之前的交集、差集、并集等关系
  1、定义集合

# 定义一个集合
se = {111,222,333,444}
或
se1 = set()  # 创建一个空集合
se1 = set((333,444))

2、常用操作

• add()方法 添加

# 创建一个空集合
s = set() 
s.add(123) # 添加元素

• clear()方法 清除集合中所有的内容

# 创建一个集合
s = set([111,222])
s.clear()  # 清除集合中所有的内容

• copy()方法 浅拷贝
  只拷贝第一层的数据

• difference() 方法 A中存在B中不存在

# 创建集合
s = set([111,222,666,777])
a = set([111,666])
print(s.difference(a))   # 取s中存在a中不存在的，计算差集

• symmetric_difference()方法 对称差集

s = set([111,222,666,777])
a = set([111,666,888])
b = s.symmetric_difference(a)  #对称差集，将s中存在a中不存在和a中存在s中不存的取出

• difference_update()方法
  取左边集合与右边集合的差集，并将结果更新到左边集合中

# 创建集合
s = set([111,222,666,777])
a = set([111,666,888]) #
# 将s中存在，a中不存在的元素查出来并更新到s中去
s.difference_update(a) #
# 输出结果：
{777, 666, 222, 111}
{777, 222}

• symmetric_difference_update() 方法
  去两个集合的对称差集，并将差集更新到左边集合中

# 创建集合
s = set([111,222,666,777])
a = set([111,666,888])
s.symmetric_difference_update(a)
输出结果：
{777, 666, 222, 111}
{888, 777, 222}

• discard()方法
  移除指定元素，元素不存在不会报错

# 创建集合
s = set([111,222,666,777])
s.discard(111) # 移除指定元素

• pop()方法
  随机移除某个元素，并返回移除的元素值
  pop方法中不能加参数

# 创建集合
s = set([111,222,666,777])
a = s.pop()
print(a) #
# 输出结果：
777

• remove()方法
  移除指定元素，元素不存在会报错

# 创建集合
s = set([111,222,666,777])
s.remove(111)

• intersection()方法
  取两个集合的交集

# 创建集合
s = set([111,222,666,777])
a = set([111,666,888])
print(s.intersection(a)) #取s和a两个集合的交集

• intersection_update()方法
  取两个集合的交集并将交集更新到左边的集合中

# 创建集合
s = set([111,222,666,777])
a = set([111,666,888])
s.intersection_update(a) #取s和a两个集合的交集，并叫交集更新到s集合中

• isdisjoint()方法
  判断两个集合有没有交集，有交集返回False，没有交集返回True

# 创建集合
s = set([111,222,666,777])
a = set([111,666,888])
print(s.isdisjoint(a))
输出结果（有交集）：
False

• issubset()
  判断左边的集合是右边集合的子序列，是返回True，否则返回False

# 创建集合
s = set([111,222,666,777])
a = set([111,666])
print(s.issubset(a))
输出结果：
False

• issuperset()
  判断左边的集合是右边集合的父序列，是返回True，否则返回False

# 创建集合
s = set([111,222,666,777])
a = set([111,666])
print(s.issuperset(a))
输出结果：
True

• union() 方法
  取两个集合的并集，把两个集合合并起来

# 创建集合
s = set([111,222,666,777])
a = set([111,888,999])
print(s.union(a))
# 输出结果：
{999, 888, 777, 666, 222, 111}

• update()方法
  批量向集合中添加元素，update可以接受一个可以循环的东西，update参数可以是字符串、列表、元组等可以迭代的元素

# 创建集合
s = set([111,222,666,777])
# 创建列表
a = [111,888,999]
s.update(a) # 批量将列表数据添加到集合中去
print(a)
# 输出结果：
{999, 777, 111, 888, 666, 222}