1 新建一个pyhton工程：
2 pycharm的几个常见用法：
调整快捷键：
python支持的数据类型：
整型：不会溢出
浮点
字符串：在""或者‘’之间，所以pyhton没有字符类型。
''' ''' 之间可以放置多行文本。
多行文本的另外一个作用，作为函数的注释使用。
print('''hello
world''')
字符串可以进行格式化拼接：
“格式字符串”%(需要格式化的数据列表)
例如：
print ("hello %d %x %s %f"%(100,200,"nihao",10.5))
python是弱类型语言，定义变量的时候，不需要指定类型。
a = 100
print(a)
b = "hello world"
c = 10.5
a = "hello 15PB"
print(a)
python中的运算符：
基本和C/C++一致，不一样的地方有：
1 逻辑运算符 and or not
2 算数运算符中，"/"能够得到整数与小数部分。 '//'只能得到整数部分。
3 ** 幂运算
a = int(input("please input a number"))
b = int(input("please input a number"))
c = a**b
d= a/b
e = b//(a+1)
print(e)
输入一个数，判断是奇数还是偶数
num = int(input("请输入一个数："))
if num%2 == 0:
print("偶数")
else:
print("奇数")
输入1到7之间的数字，输入几就输出星期几：
day = int(input("请输入一个数："))
if day<=1 or day>=8:
print("你输入的有错误")
if day==1:
print("星期一")
elif day==2:
print("星期二")
字符串操作：
\1. 去掉字符串左边或者右边的某种字符
a = " hello world "
b = "***hello*world***"
c = ""
#1 去掉字符串中的某个字符
print(a.strip())
print(b.strip("*"))
print(b.lstrip("*"))
print(b.rstrip("*"))
\2. 切分
#1 切分
b = "he*llo*wor*ld"
print(b.split("*"))
\3. 查找某一个子串的位置
b = "he*llo*wor*ld"
#3 查找某一个子串的位置
print(b.find("wo"))
\4. 查找某一个子串的数量
b = "he*llo*wor*lld"
#3 查找某一个子串的数量
print(b.count("ll"))
\5. 拼接
#1 切分,以某一个字符为标准，将字符串拆分成列表。
b = "he*llo*wor*ld"
l = b.split("*")
print(l)
#2 拼接，将列表中的内容拼成一个字符串
print("".join(l))
\6. 判断字符串是否以一个子串开头，是否以一个子串结尾
startswith()
endswith()
\7. 求字符串长度
len
\8. 切片
a = "hello world"
b = a[6:11]
c = a[0:6]
print(c,b)
切片的格式
[开始:结束:步长]
a = "hello world"
b = a[6:11:2]
c = a[0:6]
print(c,b)
切片还可以负数
-1 代表的是最后一个元素，-2代表倒数第二个
a = "hello world"
b = a[-5:]
print(b)
列表（类似于vector，是动态数组）
[]
基本使用示例，和数组差不多。
li = [1,2,3,4,5]
print(li)
print(li[0])
print(li[1])
列表中的元素，不要求数据类型一致，可以存放任意类型的数据。
li = [100,10.5,"hello world",[1,2,3,4,5],200]
print(li[0])
print(li[1])
print(li[2][0])
print(li[3][2])
列表是一个类对象，有很多操作的函数：
1 求长度 len
li = [100,10.5,"hello world",[1,2,3,4,5],200]
print(len(li))
2 拼接
li1 = [100,10.5,[1,2,3,4,5],200]
li2 = ["hello"]
li3 = li1+li2
li4= 2*li3
print(li4)
\3. 求最大值和最小值
#求最大值和最小值需要注意，类型需要是能进行比较的
li1 = [100,105,60,200]
print(max(li1))
print(min(li1))
\4. 比较两个列表
import operator
li1 = [1,2,3,4,5]
li2 = [1,2,3,4]
li3 = [5]
li2 = li2+li3
print(operator.eq(li1,li2))
\5. 列表的内置函数
增
append 添加到最后
insert 在任意位置插入数据
li1 = [1,2,3,4,5]
li1.append(100)
li1.insert(2,50)
print(li1)
删
pop 按照位置删除
remove 按照元素删除
import operator
li1 = [1,2,3,4,5]
li1.pop(2) #按位置删除
li1.remove(4) #按元素删除
print(li1)
改
[]
查
index 查找某一个元素出现的位置
import operator
li1 = [1,2,"hello",4,5]
print(li1.index("hello"))
其他函数：
计数 ： 某个元素出现的数量
count
排序：
sort 将列表中元素排序
反序：
reverse 将列表中元素顺序颠倒一下
追加：
extend 类似于+号的操作
li1 = [100,45,50,34,88,76,88]
print(li1.count(88))
li1.reverse()
print(li1)
li1.sort()
print(li1)
li1.reverse()
print(li1)
列表也是可以切片的，切片的规则和字符串是一样的
import operator
li1 = [100,45,50,34,88,76,88]
li2 = li1[0:3]
print(li2)
元组（类似于const的vector）
()
基本使用和列表是一样的，但是元组的元素是不能修改的。
字典（类似于map）
字典的每一个元素，都是由键和键值组成的键值对：
键是不可改变的量：整型 字符串 元组，不可以是列表
键值是随意的：可以是列表
di = {1:"hello",2:"world","hello":[12,3]}
print(di[1])
di[1] = "nihao"
print(di[1])
print(di["hello"])
增
setdefault：设置某一个键的键值，如果不存在这个键，就添加一个
删
del 直接删掉某一个元素
改
[键] = obj
查
get 获取某一个键的键值
has_key 查看是否存在这个键
其他：
keys() 得到所有的键 配合循环，可以遍历字典
import operator
di = {1:"hello",2:"world","hello":[12,3]}
print(di.keys())
values() 得到所有的键值
深拷贝和浅拷贝的问题：
python中的标识符，都是存储的地址
li = [1,100,3,4,5]
li1 = li.copy()
li[0] = "hello"
print(li1)
快速赋值的问题，python的元组和字典都可以快速赋值：
import operator
#元组或者列表能够整体赋值
li = (1,100,3,4,5)
a,b,c,d,e = li
print(c)
#不使用中间变量，交换两个数
a = 10
b = 20
a,b = [b,a]#(b,a)
print(a)
循环结构：
while的使用逻辑和C/C++一致
for一般用于遍历序列
遍历列表：
#1. 遍历列表
li = [10,20,15,30,45]
#for循环，每一次循环都会从列表中选出一个元素，一般用于遍历
for ele in li:
print(ele*2)
#同时输出索引和数值
for index,ele in enumerate(li):
print(index,ele)
遍历字典：
di = {100:"hello",200:"world",10:[1,2,3]}
for key in di.keys():
print(key,di[key])
循环可以跟else：
如果循环不是通过break跳出的，那么就会执行else的语句。
循环如果是正常结束的，就会执行else中的语句。
di = {100:"hello",200:"world",10:[1,2,3]}
for key in di.keys():
if key == 200:
print(key,di[key])
break
else:
print("循环正常退出")
python中函数的用法：
def add(a,b):
return a+b
def print_num(a):
print(a)
m = add(10,20)
print(m)
m = print_num(100)
print(m)
由于函数，可以传递任意类型，所以有时候，会在函数内部检测一下类型
def add(a,b):
if type(a)==int and type(b)==int:
return a+b
return None
m = add(10,[1,2,3])
print(m)
关键字传参：
def add(a,b):
print("a的值是%d"%(a))
return a+b
return None
m = add(10,20)
#可以直接指定参数名去传参，这种方式叫做关键字传参
n = add(b=100,a =200)
局部变量与全局变量:
通常定义在函数内的是局部变量，定义在函数外的是全局变量。
在函数内如果要使用全局变量，需要加上global进行声明：
sum = 10
def add(a):
#如果你想在函数内部使用全局变量,加global进行声明
global sum
for ele in a:
sum+=1
return sum
m = add("hello")
print(m,sum)
python允许在函数内部定义全局变量
def add(a):
#如果你想在函数内部使用全局变量,加global进行声明
sum = 0
global abc #这里就是声明abc是全局变量，可以在函数外部访问到
abc= 20
for ele in a:
sum+=1
return sum
m = add("hello")
print(m,abc)
可以查看到当前环境下的所有局部变量和全局变量
def add(a):
#如果你想在函数内部使用全局变量,加global进行声明
sum = 0
global abc
abc= 20
for ele in a:
sum+=1
print(locals())
return sum
m = add("hello")
print(globals())
实现列表去重
List=[1,2,3,4,4,2,6,3,3,2]
List2=list(set(List))
print(List2)
输出1！+2！+3！+4！+5！的值
def fun (n):
if n ==1:
return 1
elif n == 2:
return 2
else:
return n*fun(n-1)
print(fun(1)+fun(2)+fun(3)+fun(4)+fun(5))
水仙花数
i=153
a = i % 10 #个位数值<br>
b = (i // 10) % 10 #十位数值<br>
c = (i // 100) % 10 #百位数值 <br>
d = a*a*a + b*b*b + c*c*c
print(d)
打印菱形图案
def fun(n):
for i in range(1, 2*n, 2):
j = int(((2*n-1) - i) / 2)
print(' ' * j + '*' * i + ' ' * j)
for i in range((2*n-1)-2, 0, -2):
j = int(((2*n-1) - i) / 2)
print(' ' * j + '*' * i + ' ' * j)
fun(10)
冒泡排序
List=[20,30,40,3,6,47,25,77,15]
for i in range(len(List)-1):
for j in range(len(List)-1-i):
if List[j] < List[j+1]:
List[j], List[j+1] = List[j+1], List[j]
print(List)
杨辉三角
def Yanghui():
n=[1]
while True:
yield n
n.append(0)
n=[n[i]+n[i-1]for i in range(len(n))]
def fun(n):
for i in Yanghui():
print(i)
n-=1
if n== 0:
break
fun(10)