pycharm基础使用入门

输出

print函数

print('hello world')

右键选择run或者右上角的三角形运行，可以运行出结果

"E:\all sorts of learning programme software\python\anaconda\python.exe" "E:/code/python code/Python编程基础/python_1.py

hello world

Process finished with exit code 0

入门例子：

利用open函数将输出写入txt

# print('hello world')

string = 'hello world'

f = open('hello.txt', 'w')           # 以写的方式打开文件

f.write(string)         # 将字符串写入被打开的文件中

f.close()           # 关闭文件

在项目文件夹中就能得到一个txt文件

循环

机器学习 = ['决策树', '神经网络', '支持向量机']

for i in 机器学习:

    print(i)

    print(i)

注意：
1. 代码块以Tab或空格缩进限制，缩进是python的灵魂，一旦代码块不对齐就会发生报错
2. 中文可以作为变量名称但不推荐
3. python变量不需要提前声明，只需要直接赋值

练习1：求y=sin(x)从0到2*pi，与x轴围成的面积

python标准数据类型

number（数字）

int
float
bool
- True
- False
- 注意记得大写
complex

变量无需提前声明是整型还是浮点型，直接赋值就行。

使用例子

import math # 导入相应的数学模块

import random # 导入random包

a = -3.5

res = abs(a)

print(res)

res = math.sin(res) # 调用math包里的sin函数

math.acos(res)

print(res)

choice = random.choice(range(1, 10))

print(choice)

导包之后再使用对应函数

math包的常用函数

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如math.ceil(4.1) 返回 5
exp (x)	返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs (x)	返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)	返回数字的下舍整数，如math.floor(4.9)返回 4
log(x)	如math.log(math.e)返回1.0,math.log(100,10)返回2.0
log10(x)	返回以10为基数的x的对数，如math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
[round(x ,n])	返回浮点数x的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt (x)	返回数字x的平方根，返回类型为实数，如math.sqrt(4)返回 2+0j

string（字符串）

list（列表）

列表中每个元素都是可变的；
列表中的元素是有序的，每个元素对应一个位置；
列表可以容纳Python中的任何对象。

具体操作

# 列表

all_in_list = [0.3, 'hello', True]

print(all_in_list)

res = all_in_list[0]   # 列表的索引

res = all_in_list[-3]   # 列表从右往左的顺序

res = all_in_list[0:1]  # 列表的切片，左闭右开区间

print(res)

注意：

这是list中的顺序，要注意从右往左的负值的取法

列表的增删改插

all_in_list.append('hello world')   # 新增元素

all_in_list.insert(0,'pre-hello')

print(all_in_list)

all_in_list.remove('hello world')   # 删除元素

del all_in_list[:2]

print(all_in_list)

all_in_list[0] = 100    # 列表元素的修改

print(all_in_list)

注意：

列表的切片操作，冒号左边不填数字默认为0，右边数字不填默认为list的尾部index

列表的常用方法

名称	函数说明
list.append(obj)	在列表末尾添加新的对象
list.count(obj)	统计某个元素在列表中出现的次数
list.extend(seq)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
list.index(obj)	从列表中找出某个值第一个匹配项的索引位置
list.insert(index, obj)	将对象插入列表
list.pop(obj=list[-1])	移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
list.remove(obj)	移除列表中某个值的第一个匹配项

简单介绍for语句循环
```
# for循环

x = []

for i in range(10):

    x.append(i)

    print(x)

print(x)
```
注意：
- x = [] 就可以建一个list
- range(int x) 取值也是左闭右开，没有特殊说明起点将从0开始

列表推导式

# 列表推导式

b = [i for i in range(1, 11)]    # 列表推导式

c = [i**2 for i in range(1, 11)]

d = [i**2 for i in range(1, 11) if i % 2 == 0]

print(b)

print(c)

print(d)

注意：

第一个值为输入到表中的值
i**x 指i的x次方
接下来为for语句的写法
若有限制条件就在继续写一个if语句，对i进行限制

完成练习1：利用列表推导式和积分知识得到结果

# 练习1：求曲边图形的面积

# 利用列表推导式构建核心数据结构

import math

n = 900000

width = 2*math.pi/n

y = [abs(math.sin(i*width))*width for i in range(n)]

res = sum(y)

print(res)

dictionary（字典）

# 字典

dic = {

    'h': 'hello',

    0.5: [0.3, 0.2],

    'w': 'world'

}

# dic = {

#     'h': 'hello',

#     0.5: [0.3, 0.2],

#     'w': 'world',

#     [0]: 0.5

# }

#

print(dic)

# res = dic[0]

# print(res)

res = dic['h']  # 字典中的元素无先后顺序，通过键来访问值

print(res)

注意：

字典中的键不能是可变的值，因此使用列表当作键会报错
字典中的每个键是只能对应一个值，如果出现相同键的赋值则会发生覆盖

dic['h'] = 100

print(dic['h'])

dic['hw'] = 'hello world'   # 新增键值对

print(dic)

dic.update({1: 2, 3: 4})    # 新增多对键值对

print(dic)

del dic['h']	# 删除单个键值对

print(dic)

# del dic	# 删除字典

# print(dic)

字典推导式

a = {i: i**2 for i in range(10)}

print(a)

注意：

其实用法和for的推导式是一样的，只需要换成键值对形式

sets（集合）
tuple（元组）

程序流程控制语句

算术运算符

操作符	描述	实例
+	加法-返回两操作数相加的结果	3+2返回5
-	减法-返回左操作数减去右操作数的结果	3-2返回1
*****	乘法-返回两操作数相乘的结果	3*2返回6
/	除法-返回右操作数除左操作数的结果	3/2返回1但3.0/2返回1.5
%	模-返回右操作数对左操作数取模的结果	5%3返回2
**	指数-执行对操作指数的计算	3**2返回9
//	取商-返回右操作数对左操作数取商的结果	3.0//2返回1.0

赋值操作符

操作符	描述	例子
=	简单的赋值运算符，赋值从右侧操作数左侧操作数	c=a+b将 a和b相加的值赋值给 c
+=	加法AND赋值操作符，它增加了右操作数左操作数和结果赋给左操作数	c += a 相当于 c = c + a
-=	减法AND赋值操作符，它减去右边的操作数从左边操作数，并将结果赋给左操作数	c -= a 相当于 c = c - a
*=	乘法AND赋值操作符，它乘以右边的操作数与左操作数，并将结果赋给左操作数	c = a 相当于 c = c a
/=	除法AND赋值操作符，它把左操作数与正确的操作数，并将结果赋给左操作数	c /= a 相当于c = c / a
%=	模量AND赋值操作符，它需要使用两个操作数的模量和分配结果左操作数	c %= a相当于c = c % a
**=	指数AND赋值运算符，执行指数（功率）计算操作符和赋值给左操作数	c = a 相当于 c = c a
//=	取商，并分配一个值，执行取商并将结果赋值给左操作数	c //= a 相当于 c = c // a

比较操作符

操作符	描述	实例
==	如果两个操作数的值相等则返回True，否则返回False	3==2返回False
!=	如果两个操作数的值不等则返回True，否则返回False	3!=2返回True
<>	与!=效果相同(3.x版本中无此功能)	3<>2返回True
>	如果左操作数大于右操作数则返回True，否则返回False	3>2返回True
<	如果左操作数小于右操作数则返回True，否则返回False	3<2返回False
>=	如果左操作数大于或等于右操作数则返回True，否则返回False	3>=3返回True
<=	如果左操作数小于或等于右操作数则返回True，否则返回False	2<=2返回True

逻辑运算符

操作符	描述	实例
and	逻辑与运算符。当且仅当两个操作数为真则返回真，否则返回假。	True and False返回False
or	逻辑或运算符。当且仅当有两个操作数至少一个为真则返回真，否则返回假	True or False返回True
not	逻辑非运算符。用于反转操作数的逻辑状态。	not True 返回False

逻辑控制符的小案例

# python逻辑控制符

res = 1 < 2

print(res)  # True

res = 1 < 2 < 3

print(res)  # True

res = 'Name' == 'name'

print(res)  # False

res = 'M' in 'Magic'

print(res)  # True

注意：

python可以连续比较得出结果
python比较字符串区分大小写
python寻找字串不区分大小写

练习2：冒泡排序

对序列[1,2,6,0.3,2,0.5,-1,2.4]按从小到大顺序进行排列。

条件判断语句

# 条件判定语句

if 1 < 2:

    print('hello')  # out:hello

if 1 < 0:

    print('hello')

else:

    print('world')  # out:world

if 1 < 0:

    print('hello')

elif 2 < 1:

    print('world')

else:

    print('hehe')   # out:hehe

冒泡排序

# 冒泡排序

x = [1, 2, 6, 0.3, 2, 0.5, -1, 2.4]

n = len(x)

print(n)

for i in range(n):

    for j in range(i):

        if x[j] > x[i]:

            x[i], x[j] = x[j], x[i]

print(x)

注意：x[i], x[j] = x[j], x[i]交换语句不需要自己建立临时变量，这样写就能交换值

字符串

# 字符串

# string = "My name"

# string = '''My

#

#

# name'''

string = 'My name '

res = string[0]     # 字符串的索引

print(res)

res = string[:2]    # 切片

print(res)

res = string * 2    # 重复

print(res)

res = string + 'is xxx'

print(res)

注意：

字符串的索引和切片操作和list相似
字符串可以用单引号，可以用双引号，也可以用3引号（3个引号，不论是单引号还是双引号，三引号可以任意换行）
+ 可以将字符串拼接起来，* 可以重复字符串

res = string.split()

print(res)

res = string.split(',')

print(res)

print(string)

res = string.lower()

print(res)

# string[0] = 'y'

# print(string)

注意：

split默认以空格作为分隔符，除非用户指定了分割符
string是不可变的数据类型，分割操作没有对原字符串进行操作，而是新建了一个list副本，并且也不可以直接修改string的数据

string的常用方法

名称	说明
split(sep="",num=string.count(str))	num=string.count(str)) 以 sep 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串
S.strip([chars])	返回字符串的一个副本，删除前导和尾随字符。chars参数是一个字符串，指定要移除的字符集。如果省略或为None，则chars参数默认为删除空白字符。
S.lower()	将字符串所有大写字符变为小写
S.isalnum()	如果字符串至少有一个字符，并且所有字符都是数字或者字母，则返回true，否则返回false。
S.count(sub[,start[,end]])	返回在[start, end]范围内的子串sub非重叠出现的次数。可选参数start和end都以切片表示法解释。
replace(old, new [, max])	将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。

文件操作

# 文件操作

f = open('Walden.txt', 'r') # 以读的方式打开文件

txt = f.read()  # 读取文件内容

# txt_line = f.readlines()

f.close()   # 关闭文件

print(txt)

打开文件

访问模式	说明
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
w	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。

进阶打开模式

访问模式	说明
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

文件操作方法

模式	说明
f.close()	关闭文件，记住用open()打开文件后需得关闭它，否则会占用系统的可打开文件句柄数。
f.flush()	刷新输出缓存。
f.read([count])	读出文件全。若有count值，则读取count个字符
f.readline()	读出一行信息。
f.readlines()	读出所有行，也就是读出整个文件的信息。
f.write(string)	把string字符串写入文件。
f.writelines(list)	把list中的字符串一行一行地写入文件，是连续写入文件，没有换行。

练习3：统计小说词频

# 练习3： 统计小说中的单词频次

import re

f = open("Walden.txt", 'r')

txt = f.read()

f.close()

txt = txt.lower()

txt = re.sub('[!,.?:;"\'-]', '', txt)    # 去除小说中的标点符号

words = txt.split()		# 单词分割

word_sq = {}

for i in words:

    if i not in word_sq.keys():

        word_sq[i] = 1

    else:

        word_sq[i] += 1

res = sorted(word_sq.items(), key=lambda x: x[1], reverse=True)     # 排序

print(res)

函数

# 函数自定义

def Sum(x, y=1):

    return x + y

y = lambda x: x ** 2

y1 = lambda x: x[1]

res = Sum(1, 2)

print(res)

res = y(10)

print(res)

res = y1(['hello', 10])

print(res)

注意：

定义函数的时候，前面的函数定义了x=1 那往后的参数都要定义类似的格式，但如果是后面的的定义了y=1 则前面的无需定义成相同的格式
lambda用于快速定义函数，实现一个简单的return 功能

练习4:自定义求序列偶数个数的函数

def coulpe(x):

    z = 0

    for i in x:

        if i % 2 == 0:

            z += 1

    return z

res = coulpe([1, 2, 3, 4, 5, 6])

print(res)

注意：

python的函数不需要定义函数的返回值类型。有return就有返回值并且无需理会是什么类型的返回值，没有return就对应着各大语言的void。

面向对象

all_in_list = [2.5, 'hello', 'world', 3]

all_in_list.append('hehe')  # 对于字符串而言，没有append方法操作

print(all_in_list)

string = 'My name'

res = string.split()    # 对于列表而言，没有split方法操作

print(res)

有点编程基础的可以明白，什么是面向对象，什么叫方法~

python和一般的语言定义类不同

# 面向对象

class Human:

    def __init__(self, age=None, sex=None):

        self.age = age  # 属性

        self.sex = sex

    def square(self, x):    # 方法

        return x**2

zhangfei = Human(age=23, sex='男')

res = zhangfei.square(10)

print(res)

res = zhangfei.age

print(res)

res = zhangfei.sex

print(res)

注意：

def __init__(): python的类的构造方法要重写这个函数
初始化对象的时候，zhangfei = Human(age=23, sex='男') 要用类似的初始化格式

python模块使用

模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py

import numpy as np

from numpy import array

from numpy import *     # 一般不建议这样

想要下载第三方库：打开cmd，运行下面的命令

pip install xxxx（第三方库名）

获取工作路径

import os

path = os.getcwd()

print(path)

如果不确定，懒得去确定工作路径，可以用这个方式直接获取工作路径的字符串

注意：py文件起名尽量不要与库文件重名，会有未知的错误发生