Python学习笔记

Python开发环境安装及PyCharm安装

Python基础与运算

环境配置下载
pycharm下载

Python中标准数据类型

类型	type()
数字	/
字符串
列表
元组
集合
字典

算数运算符

意义	符号
加	+
减	-
乘	*
除	/
取模	%
幂	**
取整除	//

赋值运算符

=	+=	-=	*=	/=	%=	**=	//=

进制运算符

意义	函数
十进制转二进制	bin（i）
十进制转八进制	oct（i）
十进制转十六进制	hex（i）
二进制转十进制	int（j，2）
八进制转十进制	int（j，8）
十六进制转十进制	int（j，16）

位运算符

意义	符号	例子	结果
按位与	&	11&2	2
按位或		11，2	13
按位异或	^	11^2	9
按位取反	~	~11	-12
左移运算符	<<	8<<1	4
右移运算符	>>	2>>1	4

比较运算符

==	！=	>	<	>=	<=

注释

# 单行注释	‘’‘多行注释’’’	“”“多行注释”""

输入语句和输出语句

• 输入语句

变量=input（"提示语"）

• 输出语句

print("输出内容")

• 其他数据类型强转为字符串

result=str(result)

Python的字符串

字符串的声明

s1='string1'
s2="string2"
s3="""string3        
string4
"""           #"""   """可以打印换行符

打印结果

string1
string2
string3
string4

字符串的访问

s="Hello Python"
print(s[2])
print(s[:6])     #左闭右开

结果

l
Hello

字符串的成员运算

s1 = "Hello Python"
s2 = "e"
print(s2 in s1)             #包含运算
Print(s2 not in s1)         #不包含运算

结果

True
False

转义字符

含义	符号
换行	\n
光标到行首，打印\r之后的内容	\r
制表符	\t

打印原始字符串

print(r"Hello\nPython")
print(R"Hello\nPython")

结果

“Hello\nPython”
“Hello\nPython”

字符串格式化输出

print("我叫%s，今年%d岁"%('小明',10))    #我叫小明，今年10岁

字符串的内建函数

• 查找字符串，返回第一次出现时的位置

print("Hello Python".find(Python))     #结果为6

• 转换为小写字母

print("Hello Python".lower())          #hello python

• 转换为大写字母

print("Hello Python".upper())          #HELLO PYTHON

• 返回字符串长度

print("Hello Python".__len__())        #12

• 判断字符串是否只包含空格

print("   ".isspace())                 #True

• 字符串替换

print("Hello Python".replace('o','ee'))      #Hellee Python

查看python文档的方式
python3 -m pydoc -p 8888
浏览器中使用localhost：8888

Python组类型

列表

列表声明

l=['a','b','c',1,2,3]
print(type(l))
print(l)

结果

[‘a’, ‘b’, ‘c’, 1, 2, 3]

列表的简单操作

• 访问列表

l=['a','b','c',1,2,3]
print(l[0])
print(l[2:])

a
[‘c’, 1, 2, 3]

• 更新

l=['a','b','c',1,2,3]
l[3]=11
print(l)                   #['a', 'b', 'c', 11, 2, 3]

• 追加

l=['a','b','c',1,2,3]
l.append("new")
print(l)                    #['a', 'b', 'c', 1, 2, 3, 'new']

• 相加

l=['a','b','c',1,2,3]
l=l+["new",4]
print(l)                    #['a', 'b', 'c', 1, 2, 3, 'new', 4]

• 删除

方法1

l=['a','b','c',1,2,3]
del l[2]
print(l)                    #['a', 'b', 1, 2, 3]

方法2

l=['a','b','c',1,2,3]
l.pop(2)
print(l)                    #['a', 'b', 1, 2, 3]

方法3

l=['a','b','c',1,2,3]
l.remove('c')
print(l)                    #['a', 'b', 1, 2, 3]

• 排序

l=['b','a','c']
l.sort()
print(l)                    #['a', 'b', 'c']

• 列表长度

l=['a','b','c',1,2,3]
print(len(l))               #6

嵌套列表函数针对外层操作

嵌套列表

• 声明

l=[['a','b','c',],[1,2]]
print(l)                    #[['a', 'b', 'c'], [1, 2]]

• 访问

l=[['a','b','c',],[1,2]]
print(l[0][1])              #b

元组

元组声明

t=(1,2,3)
print(type(t))             #

元组访问

t=(1,2,3)
print(t[0])                #1

元组与列表的区别

列表可变，元组不可变，元组只能访问

集合

• 声明

#方法一
set_params = {
     '你','好','Python','你','好','Java'}
print(set_params)               #{'Python', '你', '好', 'Java'}

#方法二
set_params = set(('你','好','Python','你','好','Java'))
print(set_params)               #{'Java', '你', 'Python', '好'}

• 集合间的运算

a=set('abcdef')
b=set('abcxyz')
print(a&b)
print(a|b)
print(a^b)

{‘c’, ‘a’, ‘b’}
{‘e’, ‘a’, ‘x’, ‘b’, ‘z’, ‘y’, ‘c’, ‘d’, ‘f’}
{‘e’, ‘x’, ‘z’, ‘y’, ‘d’, ‘f’}

操作	函数
添加元素	set_params.add(“new”)
删除指定元素	set_params.remove(“a”)
随机删除一个元素	set_params.pop()
计算集合的个数	len(set_params)
清空集合	set_params.clear()

字典

• 声明

dictory={
     "a":1,"b":2,"c":3}
print(type(dictory))

{‘a’: 1, ‘b’: 2, ‘c’: 3}

• 访问

dictory={
     "a":1,"b":2,"c":3}
keys=dictory.keys();               #获取所有的键
print(keys)
print(dictory["a"])				   #根据键获取值

dict_keys([‘a’, ‘b’, ‘c’])
1

• 添加

dictory={
     "a":1,"b":2,"c":3}
dictory["d"]=4
print(dictory)                   #{'a': 1, 'b': 2, 'c': 3, 'd': 4}

条件语句

• ifelse条件句

if 条件：
	执行代码块
else ：
	执行代码块

• elif条件句

if 条件1：
	执行代码块1
elif 条件2：
	执行代码块2
elif 条件n：
	执行代码块n
else
	执行代码块

循环语句

• while循环

while 条件代码块：
   循环代码块

• for循环

count=0
for i in range(11):					#range(11) 小于11的整数
    count=count+i
print(count)						#55

• 循环的中断
  • break 跳出当前循环
  • continue 跳出本次循环

Python的组织结构

工程结构

包

模块

类

方法

变量

变量

编码规范

类型	格式	举例
包	小写字母命名，下划线分割	lower_with_under
模块	小写字母命名，下划线分割	lower_with_under
类	驼峰命名法，私有类用下划线开头	HelloWorld/_HelloWorld
函数	小写字母命名，下划线分割，私有函数下划线开头	lower_with_under/_lower_with_under
变量	小写字母命名，下划线分割，私有变量下划线开头	lower_with_under/_lower_with_under
常量	大写字母命名，下划线分割，私有常量下划线开头	CAPS_WITH_UNDER/_CAPS_WITH_UNDER

特殊模块

Python中的特殊模块 __init __.py
只有包含了 __init __.py模块的文件夹才能成为包
__init __.py时在模块导入时运行的

函数

• 定义

def my_func():
	函数代码

• 必须参数

def my_func(p1,p2):
	print(p1,p2)
my_func(1,2)		#参数个数必须对应			

• 关键字参数

def my_func(name,age):
	print(name+"来了，他今年"+str(age)+"岁！")
my_func(name = "尼古拉斯" ,age = 10)

尼古拉斯来了，他今年10岁！

• 默认参数

def my_func(name="狗蛋",age=18):
	print(name+"来了，他今年"+str(age)+"岁！")
my_func()
my_func("尼古拉斯" , age=50)

狗蛋来了，他今年18岁！
尼古拉斯来了，他今年50岁！

• 参数的混合使用

def my_func(name,age=20):
	print(name+"来了，他今年"+str(age)+"岁！")
my_func("尼古拉斯")
my_func("本拉登",age=30)

尼古拉斯来了，他今年20岁！
本拉登来了，他今年30岁！

• 带返回值的函数

def func_with_return(name,age):
    return name,age
name,age=func_with_return("肯德基",20)
print(name+"来了，他今年"+str(age)+"岁了！")
s=func_with_return("肯德基",20)		#用一个值接收多个返回值，会变为元祖类型
print(s)
print(type(s))

肯德基来了，他今年20岁了！
(‘肯德基’, 20)

• 返回值为函数

def func_return_innerfunc(x):
    if x==2 :
        def innerfunc(y):
            return  y**2
    elif x==3 :
        def innerfunc(y):
            return y**3
    else:
        def innerfunc(y):
            return "请传入正确的x值"
    return innerfunc			#返回值为函数时，只传函数名
func=func_return_innerfunc(2)
print(func(3))

9

• 递归

def my_func(x):
    if x == 1:
        return 1
    return x * my_func(x-1)		#5 * (5-1) * (4-1) * (3-1) * (2-1)
print(my_func(5))

120

• __name __

只有在本模块启动时，__name __变量等于__main __
使用方法

1. 可以作为这个模块的入口，相当于main函数

if __name__ == __main__
		print("模块入口")

2.也可以作为调试使用，原因是，在其他模块调用本模块时__name__==__main__判断结果为False,所以就不会执行