pycharm基础使用入门

Posted 2021-03-06 cell-coder

pycharm基础使用入门

输出

1. print函数

   print('hello world')

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

   "E:all sorts of learning programme softwarepythonanacondapython.exe" "E:/code/python code/Python编程基础/python_1.py
   hello world
   
   Process finished with exit code 0

入门例子：

1. 利用open函数将输出写入txt

   # print('hello world')
   string = 'hello world'
   f = open('hello.txt', 'w')           # 以写的方式打开文件
   f.write(string)         # 将字符串写入被打开的文件中
   f.close()           # 关闭文件

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

2. 循环

   机器学习 = ['决策树', '神经网络', '支持向量机']
   for i in 机器学习:
       print(i)
       print(i)

3. 注意：

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

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

1. python标准数据类型

   1. number（数字）

      • int

      • float

      • bool
        • True
        • False
        • 注意记得大写

      • complex

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

      2. 使用例子

         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

   2. string（字符串）

   3. 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)

   4. 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)

      注意：

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

      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的推导式是一样的，只需要换成键值对形式

   5. sets（集合）

   6. tuple（元组）

程序流程控制语句

1. 算术运算符

   操作符	描述	实例
   +	加法-返回两操作数相加的结果	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

2. 赋值操作符

   操作符	描述	例子
   =	简单的赋值运算符，赋值从右侧操作数左侧操作数	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

3. 比较操作符

   操作符	描述	实例
   ==	如果两个操作数的值相等则返回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

4. 逻辑运算符

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

5. 逻辑控制符的小案例

   # 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

   注意：

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

练习2：冒泡排序

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

1. 条件判断语句

   

   # 条件判定语句
   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

2. 冒泡排序

   # 冒泡排序
   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)
   

   注意：

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

   res = string.split()
   print(res)
   res = string.split(',')
   print(res)
   print(string)
   res = string.lower()
   print(res)
   # string[0] = 'y'
   # print(string)

   注意：

   1. split默认以空格作为分隔符，除非用户指定了分割符
   2. 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)

1. 打开文件

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

2. 进阶打开模式

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

3. 文件操作方法

   模式	说明
   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)

注意：

1. 定义函数的时候，前面的函数定义了x=1 那往后的参数都要定义类似的格式，但如果是后面的的定义了y=1 则前面的无需定义成相同的格式
2. 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)

注意：

1. 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)

注意：

1. def __init__(): python的类的构造方法要重写这个函数
2. 初始化对象的时候，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文件起名尽量不要与库文件重名，会有未知的错误发生