我开始学python了hhhhh

前言

为什么要学python呢，一方面是作为一个学材料的工科生觉得平时的科研工作有点无趣，在无聊的时候打发时间，另一方面python在我最近做的一个项目中有需求，具体来说需求的并不是python，需要的是图像处理，但总得用一门编程语言不是，选来选去觉得python最好（PS：这个项目算是我自己主动找老板申请的，我觉得这个有意思hhh，某些时候比打游戏还有意思）。
在CSDN上写这个博客主要是记录我的学习过程，前期已经学了两周的python，因此，这第一篇就用来复习我前段时间学到的东西（在B站上看的小甲鱼的视频课）。
关于学习博客的内容我打算这样写，前面写python中我所学的各种python调用函数或特殊字符，后面则是一些关于算法的小的编程。总之，准小白的python之旅由此开始了。
python的安装目前是微软的商店自动安装的，感觉比较好，各种坑都能避过，编码主要在IDLE中进行。

Python

入门小游戏

help  #python帮助文档调用
input #输入某个值
print #在屏幕上打印某个参数
a%b   #a/b余几
%c    #返回“c”的ASCII码
int() #返回整型
str() #返回字符串
float()#返回浮点型，科学计数法
range(a,b,c)  #在[a,b]范围内以步长c选取
random（a,b)  #（a，b）内选取随机数
len    #给出字符长度
list/[]   #转化为列表
tuple /() #转化为元组
set/{}    #创建集合
def       #定义函数
import    #调用
!=        #不等于
==        #等于
break     #终止循环

关于上面学到的内置关键词，主要两个事情需要说明一下，一个是python的数据类型只有三种，即上面给出的整型，字符串，浮点型；另一个是数据的存在形式元组，列表，集合，他们在python中标志性符号分别是（），[ ] ，{ }。

import random
secert = random.randint(1,10)  #产生一个随机数
print(".......S1......")       #S1第一个小程序
temp=input("我在想啥")           
guess=int(temp)
if guess == secert:            #判断代码块
		print("Right")
else :
    if guess > secert:
        print("Big")
    else:
        print("Small")
while guess != secert:         #循环语句，直到guess等于secret结束循环
	temp=input("我在想啥")  
	guess=int(temp)
	if guess == secert:
		print("Right")
	else:
		if guess > secert:
			print("Big")	
		else:
			print("Small")
print("游戏结束")

根据前面的关键词及两个结构编写而成的数字小游戏，用来猜测系统随机生成的随机数是多少，同时在出错时给出一定信息。主要是学习if/else判断结构以及while循环结构（其含义是while后面的条件成立时，一直执行循环体内部的语句，直到不成立时结束）。
关于python代码的风格，与大学时期学习VB相比，主要没有一些标点，更为简洁，但python中的tab也就是缩进十分重要，同一层次的结构的缩进值必须相同，这样使得代码看上去结构非常清晰。

链表

list(iterable=(), /)
 |  
 |  Built-in mutable sequence.
 |  
 |  If no argument is given, the constructor creates a new empty list.
 |  The argument must be an iterable if specified.
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(self, /)
 |      Return a reverse iterator over the list.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(self, /)
 |      Return the size of the list in memory, in bytes.
 |  
 |  append(self, object, /)
 |      Append object to the end of the list.
 |  
 |  clear(self, /)
 |      Remove all items from list.
 |  
 |  copy(self, /)
 |      Return a shallow copy of the list.
 |  
 |  count(self, value, /)
 |      Return number of occurrences of value.
 |  
 |  extend(self, iterable, /)
 |      Extend list by appending elements from the iterable.
 |  
 |  index(self, value, start=0, stop=9223372036854775807, /)
 |      Return first index of value.
 |      
 |      Raises ValueError if the value is not present.
 |  
 |  insert(self, index, object, /)
 |      Insert object before index.
 |  
 |  pop(self, index=-1, /)
 |      Remove and return item at index (default last).
 |      
 |      Raises IndexError if list is empty or index is out of range.
 |  
 |  remove(self, value, /)
 |      Remove first occurrence of value.
 |      
 |      Raises ValueError if the value is not present.
 |  
 |  reverse(self, /)
 |      Reverse *IN PLACE*.
 |  
 |  sort(self, /, *, key=None, reverse=False)
 |      Sort the list in ascending order and return None.
 |      
 |      The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
 |      order of two equal elements is maintained).
 |      
 |      If a key function is given, apply it once to each list item and sort them,
 |      ascending or descending, according to their function values.
 |      
 |      The reverse flag can be set to sort in descending order.
 |  

链表是一个大杂烩，一个链表中的元素可以是同一个类别的，也可以是不同类别的，关于链表的调用，在链表的帮助中已经给出，我们有何种需求时，可以用list.x x为要采用的方法。大佬给出了一些常用链表的使用方法，比帮助文档好理解。

循环（for）与递归

for i in range(1,10):
	if i%2 != 0:
		print(i)
		continue
	i +=2
	print(i)
	#输出结果为1 4 3 6 5 8 7 10 9

程序的执行（按顺序输入1-10 9个数字，首先输入的是1，判断1/2是否能被整除，不能，则输出 1 continue继续执行for循环，输入2，判断2是否能被整除，可以，执行2+2，输出4，循环继续，输入3，，，，）理解for循环与continue语句

#菲波那切数列的实现递归方法
def function(n):
    if n == 1:
        return 1
    if n == 2:
        return 1
    else:
        return function(n-1)+function(n-2) #递归
  
num = int(input(""))
result = function(num)
print(result)                #根据输入的数字求函数值

#菲波那切数列的实现循环方法
def function(n):
    n1 = 1
    n2 = 1
    n3 = 1
    if n == 1:
        return 1
    if n == 2:
        return 1
    while n - 2 > 0:
         n3 = n1 + n2
         n1 = n2
         n2 = n3
         n -= 1
    return n3

number = int(input('piease input number'))
result = function(number)
print('result is %d' %result)

#汉诺塔的递归实现
def hanoi(n,x,y,z):
    if n == 1:
        print(x,"-->",z)
    else:
        hanoi(n-1,x,z,y)#将前n-1个盘子从x移动到y
        print(x,"-->",z)
        hanoi(n-1,y,x,z)#将y上的n-1个盘子移动到z

n =int(input())
hanoi(n,'X','Y','Z')

#汉诺塔的循环实现
def hanoi(n):
    tower_belong = [0] * n
    if n % 2 == 0:
        tower_name = ['A', 'B', 'C']
    else:
        tower_name = ['A', 'C', 'B']
    for step in range(1, 2 ** n):
        bin_step = bin(step)
        gold_num = len(bin_step) - bin_step.rfind('1') - 1

        print(f"第 {step:2} 步：移动 {str(gold_num)} 号金片，从 {tower_name[tower_belong[gold_num]]} 塔到", end=' ')
        if gold_num % 2 == 0:
            tower_belong[gold_num] = (tower_belong[gold_num] + 1) % 3
        else:
            tower_belong[gold_num] = (tower_belong[gold_num] + 2) % 3
        print(tower_name[tower_belong[gold_num]], '塔')

hanoi(3)

递归其实就是自己调用自己，代码效率不高，但编程较为容易，一般递归问题均可以通过循环实现，但比较难，，，这里的代码来自汉诺塔实现