Création D'un Formulaire Contrôlé Avec React Hook Forms

React Hook Forms est une bibliothèque de formulaires permettant aux applications React de créer des formulaires avec une validation facile à configurer via le processus d'appel de crochets pour créer l'état et le contexte du formulaire. React Hook Forms sert d'alternative à une autre bibliothèque de formulaires populaire, Formik. Les cas d'utilisation de React Hook Forms sont la facilité avec laquelle il est possible de gérer des gestionnaires d'événements tels que onSubmit, onChange, onBluretc.

À mon avis, il s'agit d'une bibliothèque facile à utiliser en raison de la facilité de navigation dans la documentation ainsi que de la flexibilité du contrôle de formulaire fourni - un développeur peut développer des formulaires de base avec des champs de saisie html par défaut, ou ils peuvent développer des formulaires complexes avec un comportement programmatique qui utilise à la fois des composants personnalisés, intégrés et externes.

Créer un formulaire dans React sans bibliothèque de formulaires

Passons en revue la création d'un formulaire d'inscription pour un site en utilisant React et TypeScript. Dans cet exemple, nous allons créer un formulaire contrôlé, ce qui signifie que nous traitons les données directement à l'aide de React plutôt que de les faire traiter implicitement par React.

1. Commençons par initialiser notre fichier pour créer le formulaire.

export const BetaMaleForm = (): JSX.Element => {
  return <></>;
};

1. Ajoutons maintenant nos champs de saisie nécessaires au formulaire d'inscription. Dans cet exemple, nous aurons un nom d'utilisateur, un mot de passe et des champs d'e-mail, avec un bouton d'envoi pour publier le formulaire.

export const BetaMaleForm = (): JSX.Element => {
  return (
    <form onSubmit={handleSubmit}>
      <Label>
        Username:
        <input type="text" name="username" />
      </Label>
      <Label>
        Password:
        <input type="password" name="password" />
      </Label>
      <Label>
        Email:
        <input type="email" name="fullName" />
      </Label>
      <input type="submit" value="Submit">
    </form>
  );
};

1. Ensuite, nous devrons implémenter un stockage pour contenir les valeurs que chaque champ contiendra.

export const BetaMaleForm = (): JSX.Element => {
  const [username, setUsername] = useState("");
  const [password, setPassword] = useState("");
  const [email, setEmail] = useState("");

  return (
    <form onSubmit={handleSubmit}>
      <Label>
        Username:
        <input type="text" name="username" value={username} />
      </Label>
      <Label>
        Password:
        <input type="password" name="password" value={password} />
      </Label>
      <Label>
        Email:
        <input type="email" name="fullName" value={email} />
      </Label>
      <input type="submit" value="Submit">
    </form>
  );
};

1. Enfin, lorsque l'utilisateur tape, nous devons être en mesure de prendre ses mises à jour et de les appliquer à la valeur du champ en capturant les événements de modification. C'est là qu'intervient le concept de composant contrôlé.

export const BetaMaleForm = (): JSX.Element => {
  const [username, setUsername] = useState("");
  const [password, setPassword] = useState("");
  const [email, setEmail] = useState("");

  const handleSubmit = () => {
    alert(`Username: ${username}, Password: ${password}, Email: ${email}`);
  };

  const handleUsernameChange = (e: ChangeEvent) => setUsername(e.target.value);

  const handlePasswordChange = (e: ChangeEvent) => setPassword(e.target.value);

  const handleEmailChange = (e: ChangeEvent) => setEmail(e.target.value);

  return (
    <form onSubmit={handleSubmit}>
      <Label>
        Username:
        <input
          type="text"
          name="username"
          onChange={handleUsernameChange}
          value={username}
        />
      </Label>
      <Label>
        Password:
        <input
          type="password"
          name="password"
          onChange={handlePasswordChange}
          value={password}
        />
      </Label>
      <Label>
        Email:
        <input
          type="email"
          name="fullName"
          onChange={handleEmailChange}
          value={email}
        />
      </Label>
      <input type="submit" value="Submit">
    </form>
  );
};

Avaient fini! Nous avons créé un formulaire d'inscription à l'aide de React en utilisant les crochets intégrés pour gérer le stockage et la capture des modifications. Cependant, imaginez qu'au fil du temps, lorsque vous devrez gérer ce fichier, vous devrez ajouter plus de champs au fichier. Cela signifierait plus de useStatecrochets, puis plus onChangede gestionnaires à écrire. Cela augmenterait la longueur de notre fichier de composants et contribuerait à l'illisibilité.

Un petit avertissement - la raison pour laquelle il y a beaucoup de code est à cause de la façon dont nous transformons le formulaire en un composant contrôlé. Si vous préférez créer un composant non contrôlé, vous n'aurez pas besoin de vous concentrer sur l'ajout de gestionnaires pour les modifications d'entrée ou les soumissions. Ce n'est que lorsque nous voulons que React détienne la source unique de vérité pour les valeurs de formulaire que nous utilisons des composants contrôlés.

Un risque de ce fichier de composant est que plus il y a de champs à ajouter au formulaire, plus il y a de gestionnaires et d'états à créer - cela ne fera qu'empirer si un formulaire nécessite des comportements avancés tels que des gestionnaires de touches pour chaque champ , la fonctionnalité de texte prédictif et la fonctionnalité permettant de se concentrer sur le champ suivant.

Utilisation des formulaires de crochet React

Maintenant que nous avons vu comment créer un formulaire en utilisant les crochets intégrés de React, faisons la même chose mais en utilisant la bibliothèque React Hook Form. Je vais vous guider à travers cela progressivement.

La première fonction qui doit être appelée pour initialiser notre formulaire est le useFormcrochet. L'objectif principal de ce crochet est de mettre en place la gestion et l'état du formulaire qui seront partagés entre tous les champs liés au formulaire.

Le useFormcrochet renverra des propriétés utiles pour nous aider à gérer le comportement du formulaire. Cet objet est ce que nous appelons methodsqui contient plusieurs fonctions utiles que le développeur peut utiliser pour initialiser la gestion du formulaire.

const methods = useForm();

Passons en revue les crochets fournis par le formulaire et reconstruisons le formulaire que nous avons créé depuis le début. Nous allons d'abord ajouter le useFormcrochet au composant et supprimer tous les gestionnaires d'état et de changement de l'exemple précédent :

export const AbsoluteChadForm = (): JSX.Element => {
  const methods = useForm();

  return (
    <form onSubmit={handleSubmit}>
      <Label>
        Username:
        <input type="text" name="username" />
      </Label>
      <Label>
        Password:
        <input type="text" name="password" />
      </Label>
      <Label>
        Email:
        <input type="text" name="fullName" />
      </Label>
      <input type="submit" value="Submit">
    </form>
  );
};

En approfondissant les methodsobjets, cela contiendra plusieurs fonctions qui permettent de contrôler le comportement du formulaire. Les méthodes que j'aimerais présenter sont les suivantes :

• register- enregistre un champ dans le formulaire défini par useForm
• setValue- définit par programme une valeur de champ d'entrée en accédant au nom de la clé de la valeur
• getValues- renvoie toutes les valeurs non nulles saisies dans le formulaire
• handleSubmit- gère la soumission en prenant des rappels qui définissent comment la soumission est gérée et comment les erreurs sont gérées

Les développeurs devront appeler useFormpar formulaire qu'ils veulent créer, par exemple s'il y a 5 formulaires sur une seule page et que toute la logique est écrite sur un seul fichier, alors useFormils seront appelés 5 fois pour gérer chaque formulaire en conséquence.

Le hook lui-même peut prendre un objet en tant que paramètre avec un ensemble d'options qui sont transmises pour configurer le comportement du formulaire personnalisé. Les options utiles incluent :

• Définition modedu formulaire - le mode détermine le moment où la validation du formulaire se produira, par exemple si mode = 'onChange', lorsqu'un champ de saisie de connexion déclenche un événement de modification, la validation du formulaire se produira
• Définition des valeurs par défaut du champ de texte

Ajoutons un peu de configuration au formulaire en définissant explicitement le mode de soumission et les valeurs par défaut pour chacune des entrées :

export const AbsoluteChadForm = (): JSX.Element => {
  const methods = useForm({
    mode: "onSubmit",
    defaultValues: { username: "", password: "", email: "" },
  });

  return (
    <form onSubmit={handleSubmit}>
      <Label>
        Username:
        <input type="text" name="username" />
      </Label>
      <Label>
        Password:
        <input type="text" name="password" />
      </Label>
      <Label>
        Email:
        <input type="text" name="fullName" />
      </Label>
      <input type="submit" value="Submit">
    </form>
  );
};

La méthode la plus importante est la registerméthode car elle permet à un développeur de connecter un composant d'entrée au formulaire défini par useForm(). En effet, register renvoie 4 attributs importants :

const { onChange, onBlur, ref, name } = register("fullName");

Comme lorsque nous avions le onChangegestionnaire dans notre formulaire sans la bibliothèque, cette onChangefonction gérera tous les événements de clavier qui sont déclenchés lorsqu'ils sont concentrés sur le champ de saisie. Les refet onBlurseront utilisés pour gérer quand l'entrée est focalisée ou non. Enfin, nameest l'attribut nécessaire requis pour transmettre des valeurs à un formulaire HTML.

Cette fonction de registre peut être implémentée dans le formulaire en déconstruisant l'objet renvoyé par la fonction et en les passant comme accessoires aux champs d'entrée que nous avons :

export const AbsoluteChadForm = (): JSX.Element => {
  const methods = useForm({
    mode: "onSubmit",
    defaultValues: {
      fullName: "",
      email: "",
      password: "",
    },
  });

  const onSubmit = () => {
    console.log(methods.getValues());
  };

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      <input {...methods.register("fullName")} type="text" name="fullName" />
      <input {...methods.register("email")} type="email" name="email" />
      <input
        {...methods.register("password")}
        type="password"
        name="password"
      />
      <input type="submit" value="Submit" />
    </form>
  );
};

En comparant la fonctionnalité de la bibliothèque à un formulaire utilisant des crochets React intégrés, un avantage évident de l'utilisation de cette bibliothèque est le nombre minimal de lignes requises pour un fichier de composant. En effet, les gestionnaires de modification et de soumission peuvent être supprimés et les crochets useState ne sont pas nécessaires. Les développeurs peuvent simplement "accrocher" les entrées dans le formulaire à l'aide de la méthode register (tout en lui transmettant une référence aux valeurs du formulaire auxquelles le champ d'entrée se connecte aka name).

En permettant aux développeurs de simplement "s'accrocher" aux champs de saisie définis dans le formulaire via useFormet des références nommées, vous pouvez facilement définir des valeurs/espaces réservés par défaut sans avoir à les gérer manuellement pour chaque entrée - la maintenance de l'expérience utilisateur est réduite.

Ajout de validation avec React Hook Forms

La beauté de la registerfonction est qu'elle peut être utilisée pour définir des règles de validation pour le champ de saisie adressé. Dans ce cas, disons que nous voulons avoir des règles de validation pour le champ mot de passe qui sont les suivantes :

• minimum 8 caractères
• a une lettre majuscule
• a un caractère spécial

La validation peut être définie en passant un objet avec les règles requises à la registerfonction en tant que paramètre.

<input
  {...register("fullName", { required: true, minLength: 8, pattern: "" })}
  type="text"
  name="fullName"
/>

Lorsque l'utilisateur clique sur le bouton d'envoi, modeétant donné qu'il est défini sur 'soumettre', la validation sera effectuée sur le clic du bouton d'envoi, et cela implique de vérifier les règles de validation définies dans la registerfonction.

Vous trouverez des informations sur l'ajout de fonctions définies par l'utilisateur pour les règles de validation dans la documentation de register. React Hook Forms a également la possibilité d'utiliser la validation Yup en plus des méthodes de validation existantes.

Plonger dans les sujets avancés

Utilisation de React Hook Forms avec des bibliothèques de composants

Une grande utilisation de React Hook Forms qui a été utile pour mes projets a été son intégration avec des bibliothèques de composants telles que Material UI ou Chakra UI. Si une équipe de développement souhaite créer un MVP avec une bibliothèque de composants tout en ayant une connexion facile à la bibliothèque de formulaires de crochet React, alors Controllerc'est une bouée de sauvetage.

Controllerest un composant wrapper qui peut être utilisé pour envelopper les composants et propager les attributs et les comportements de forme de crochet de réaction jusqu'aux composants

export const ControlledForm = (): JSX.Element => {
  const methods = useForm({
    mode: "onSubmit",
    defaultValues: {
      fullName: "",
      email: "",
      password: "",
    },
  });

  const onSubmit = () => {
    console.log(methods.getValues());
  };

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      <input {...methods.register("fullName")} type="text" name="fullName" />
      <Controller
        control={methods.control}
        name="email"
        render={({
          field: { onChange, onBlur, value, name, ref },,
          formState,
        }) => (
          <TextField
            type="text"
            variant="outlined"
            onChange={onChange}
            onBlur={onBlur}
            name={name}
            value={value}
          />
        )}
      />
      <input
        {...methods.register("password")}
        type="password"
        name="password"
      />
      <input type="submit" value="Submit" />
    </form>
  );
};

Bien que cette méthode soit facile à lire, en plus d'être facile à mettre en œuvre, pour intégrer des composants externes dans votre application, une solution plus propre peut être d'utiliser la useControllerfonction hook à la place.

import { TextField } from "@mui/material";
import { useController } from "react-hook-form";

interface CustomInputProps {
  name: string;
  control: Object;
}

export const CustomInput = ({
  name,
  control,
}: CustomInputProps): JSX.Element => {
  const {
    field: { onChange, onBlur, name, value, ref },
  } = useController({
    name,
    control,
    rules: { required: true },
  });

  return (
    <TextField
      type="text"
      variant="outlined"
      onChange={onChange}
      onBlur={onBlur}
      name={name}
      value={value}
    />
  );
};

Cela permettra aux développeurs de garder leur code plus propre en ajoutant un crochet dans le fichier de composant plutôt que d'avoir un wrapper sur le fichier de page. Mis à part la différence que l'un est un emballage et l'autre un crochet, ils ont tous les deux le même comportement.

Les variables clés pour contrôler un composant est la controlvariable. Il s'agit d'un objet renvoyé par la registerfonction dans le but d'enregistrer des composants dans le formulaire créé. L'accès au contenu de cette variable n'est pas recommandé par react-hook-forms.

Comportement d'entrée complexe

J'ai mentionné précédemment que l'avantage des formulaires de crochet de réaction est qu'il abstrait la gestion des écouteurs d'événements du côté de la bibliothèque pour mettre à jour les valeurs dans les champs d'entrée et les stocker en conséquence, mais la bibliothèque n'est pas limitée à cette abstraction car elle vous permet de définir manuellement quand déclencher les gestionnaires d'événements sur les champs de saisie pour mettre à jour les valeurs du formulaire à tout moment.

En rappelant la registerfonction, plutôt que de déconstruire la fonction à l'intérieur d'un élément d'entrée, vous pouvez définir register comme suit :

const { onChange } = register("firstName")

...

<input onChange={onChange} type='text' name='fullName' />

Si vous déconstruisez les accessoires avant de les transmettre au champ de saisie pour vous connecter au formulaire, vous pouvez définir manuellement chaque propriété individuelle fournie par register. L'inconvénient de cette approche pour un formulaire de base est que vous pouvez omettre des gestionnaires d'événements importants fournis par la fonction et que vous n'obtenez pas le comportement approprié pour votre formulaire. Cependant, si vous avez besoin que la logique métier soit exécutée avant d'appeler la onChangefonction, vous pouvez le faire, puis appeler onChangeavec la nouvelle valeur d'entrée formatée passée en paramètre.

Composants de formulaire complexes + réutilisabilité

Un problème commun auquel j'ai été confronté dans les projets sur lesquels j'ai travaillé est l'évolutivité des formulaires pour s'adapter aux nouveaux champs de formulaire, ainsi que l'utilisation d'un comportement de formulaire complexe. Pour résoudre le problème de l'évolutivité, vous devez envisager deux approches pour créer des composants de champ de formulaire :

1. Création de composants de champ de formulaire React pouvant être réutilisés
2. Créer des composants de champ avec des comportements complètement différents.

Vous pourriez vous demander pourquoi vous ne pouvez pas avoir les deux approches dans une base de code. Vous pouvez absolument le faire, mais à mon avis, cela rend la base de code désordonnée. Je recommande donc d'essayer de diviser ces approches en deux, en utilisant certains des crochets sous-utilisés de React Hook Forms.

Composants réutilisables

React Hook Forms a un article dédié à la création d'un "composant de formulaire intelligent" , qui consiste à créer un composant wrapper avec le useFormcrochet appelé à l'intérieur, et à transmettre les méthodes de formulaire aux composants, qu'il s'agisse d'une sélection de méthodes triées sur le volet ou de toutes . Le résultat est que vous avez un composant wrapper qui injecte des méthodes de formulaire dans les composants enfants à l'intérieur du wrapper :

// From the React Hook Form guide

import React from "react";
import { useForm } from "react-hook-form";

interface FormProps {
	defaultValues: { firstName: string, email: string, password: string },
	children: JSX.Element[],
	onSubmit: () => void,
}

export const Form = ({ defaultValues, children, onSubmit }: FormProps): JSX.Element {
  const methods = useForm({ defaultValues });
  const { handleSubmit } = methods;

  return (
    <form onSubmit={handleSubmit(onSubmit)}>
      {React.Children.map(children, child => {
        return child.props.name
          ? React.createElement(child.type, {
              ...{
                ...child.props,
                register: methods.register,
                key: child.props.name
              }
            })
          : child;
       })}
    </form>
  );
}

import React from "react";
import { Form, Input, Select } from "./Components";

export const SmartForm = (): JSX.Element => {
  const onSubmit = (data) => console.log(data);

  return (
    <Form onSubmit={onSubmit}>
      <input type="text" name="fullName" />
      <input type="email" name="email" />
      <input type="password" name="password" />
      <input type="submit" value="Submit" />
    </Form>
  );
};

Composants nécessitant un comportement complexe

S'il s'avère qu'un composant de formulaire nécessite un comportement complexe qui ne doit pas être réutilisé pour un composant différent, il est alors judicieux de comprendre comment accéder aux méthodes de formulaire et à l'état requis. Un bon crochet à utiliser est useFormContextcelui qui agit de manière très similaire à celui de React useContext. Ce crochet vous permet de récupérer les méthodes de formulaire fournies par useFormsans avoir à rappeler le crochet (car si vous le faites, un nouveau formulaire est initialisé).

export const AbsoluteChadForm = (): JSX.Element => {
  const methods = useForm({
    mode: "onSubmit",
    defaultValues: {
      fullName: "",
      email: "",
      password: "",
    },
  });

  const onSubmit = () => {
    console.log(methods.getValues());
  };

  return (
    <FormProvider {...methods}>
      <form onSubmit={handleSubmit(onSubmit)}>
        <input {...register("fullName")} type="text" name="fullName" />
        <input {...register("email")} type="email" name="email" />
        <input {...register("password")} type="password" name="password" />
        <ComplexBehavingComponent name="complexField" />
        <input type="submit" value="Submit" />
      </form>
    </FormProvider>
  );
};

interface ComplexBehavingComponentProps {
	name: string
}

export const ComplexBehavingComponent = ({name}: ComplexBehavingComponentProps): JSX.Element => {
	const { register, setValue, getValues } = useFormContext()

	const onChange = (e: ChangeEvent) => {
		if (e.target.value === 'hello world') setValue(name, 'software dev')
	}

	return (
		<input {...register(name, { onChange: onChange }) type='text' name={name} />
	)
}

Les avantages de ce crochet sont qu'au lieu d'avoir à prop drill aux composants de niveau inférieur, ou si vous souhaitez connecter des composants plus bas dans l'arborescence DOM au composant Form au niveau supérieur, cela est possible en utilisant le FormProviderwrapper au niveau où form les données seront envoyées aux accessoires enfants et petits-enfants, puis accessibles avec le useFormContextcrochet.

Sommaire

Dans l'ensemble, nous avons examiné l'utilisation des bases de React Hook Forms, les avantages qu'il offre en tant que développeur par rapport à l'utilisation des crochets existants de React, et avons fourni des exemples sur la façon de tirer parti des utilitaires de React Hook Form pour un comportement de formulaire complexe. J'espère que cet article vous a inspiré à utiliser la bibliothèque et à rendre vos formulaires React incroyablement efficaces. Pour plus d'informations sur React Hook Forms, consultez le site Web pour accéder à la documentation de l'API .

Source : https://blog.theodo.com/2022/06/react-hook-forms/

#react 

What is GEEK

Buddha Community

How native is React Native? | React Native vs Native App Development

If you are undertaking a mobile app development for your start-up or enterprise, you are likely wondering whether to use React Native. As a popular development framework, React Native helps you to develop near-native mobile apps. However, you are probably also wondering how close you can get to a native app by using React Native. How native is React Native?

In the article, we discuss the similarities between native mobile development and development using React Native. We also touch upon where they differ and how to bridge the gaps. Read on.

A brief introduction to React Native

Let’s briefly set the context first. We will briefly touch upon what React Native is and how it differs from earlier hybrid frameworks.

React Native is a popular JavaScript framework that Facebook has created. You can use this open-source framework to code natively rendering Android and iOS mobile apps. You can use it to develop web apps too.

Facebook has developed React Native based on React, its JavaScript library. The first release of React Native came in March 2015. At the time of writing this article, the latest stable release of React Native is 0.62.0, and it was released in March 2020.

Although relatively new, React Native has acquired a high degree of popularity. The “Stack Overflow Developer Survey 2019” report identifies it as the 8th most loved framework. Facebook, Walmart, and Bloomberg are some of the top companies that use React Native.

The popularity of React Native comes from its advantages. Some of its advantages are as follows:

• Performance: It delivers optimal performance.
• Cross-platform development: You can develop both Android and iOS apps with it. The reuse of code expedites development and reduces costs.
• UI design: React Native enables you to design simple and responsive UI for your mobile app.
• 3rd party plugins: This framework supports 3rd party plugins.
• Developer community: A vibrant community of developers support React Native.

Why React Native is fundamentally different from earlier hybrid frameworks

Are you wondering whether React Native is just another of those hybrid frameworks like Ionic or Cordova? It’s not! React Native is fundamentally different from these earlier hybrid frameworks.

React Native is very close to native. Consider the following aspects as described on the React Native website:

• Access to many native platforms features: The primitives of React Native render to native platform UI. This means that your React Native app will use many native platform APIs as native apps would do.
• Near-native user experience: React Native provides several native components, and these are platform agnostic.
• The ease of accessing native APIs: React Native uses a declarative UI paradigm. This enables React Native to interact easily with native platform APIs since React Native wraps existing native code.

Due to these factors, React Native offers many more advantages compared to those earlier hybrid frameworks. We now review them.

#android app #frontend #ios app #mobile app development #benefits of react native #is react native good for mobile app development #native vs #pros and cons of react native #react mobile development #react native development #react native experience #react native framework #react native ios vs android #react native pros and cons #react native vs android #react native vs native #react native vs native performance #react vs native #why react native #why use react native

What are hooks in React JS? - INFO AT ONE

In this article, you will learn what are hooks in React JS? and when to use react hooks? React JS is developed by Facebook in the year 2013. There are many students and the new developers who have confusion between react and hooks in react. Well, it is not different, react is a programming language and hooks is a function which is used in react programming language.
Read More:- https://infoatone.com/what-are-hooks-in-react-js/

#react #hooks in react #react hooks example #react js projects for beginners #what are hooks in react js? #when to use react hooks

Validating React Forms With React-Hook-Form

Validating inputs is very often required. For example, when you want to make sure two passwords inputs are the same, an email input should in fact be an email or that the input is not too long. This is can be easily done using React Hook From. In this article, I will show you how.

Required Fields

The most simple, yet very common, validation is to make sure that an input component contains input from the user. React Hook Form basic concept is to register input tags to the form by passing register() to the tag’s ref attribute. As we can see here:

#react-native #react #react-hook-form #react-hook

如何使用 Tweepy 和 Snscape 从 Twitter 上抓取数据

如果您是数据爱好者，您可能会同意社交媒体是现实世界数据中最丰富的来源之一。像 Twitter 这样的网站充满了数据。

您可以通过多种方式使用从社交媒体获得的数据，例如针对特定问题或感兴趣领域的情绪分析（分析人们的想法）。

您可以通过多种方式从 Twitter 上抓取（或收集）数据。在本文中，我们将研究其中两种方式：使用 Tweepy 和 Snscrap。

我们将学习一种方法来抓取人们关于特定趋势主题的公开对话，以及来自特定用户的推文。

现在事不宜迟，让我们开始吧。

Tweepy vs Snscrape——我们的抓取工具简介

现在，在我们进入每个平台的实现之前，让我们尝试掌握每个平台的差异和限制。

呸呸呸

Tweepy 是一个用于与 Twitter API 集成的 Python 库。因为 Tweepy 与 Twitter API 连接，除了抓取推文之外，您还可以执行复杂的查询。它使您能够利用 Twitter API 的所有功能。

但也有一些缺点——比如它的标准 API 只允许您收集长达一周的推文（也就是说，Tweepy 不允许恢复超过一周窗口的推文，因此不允许检索历史数据）。

此外，您可以从用户帐户中检索多少条推文也是有限制的。您可以在此处阅读有关 Tweepy 功能的更多信息。

刮擦

Snscape 是另一种从 Twitter 上抓取信息的方法，不需要使用 API。Snscrape 允许您抓取基本信息，例如用户的个人资料、推文内容、来源等。

Snscape 不仅限于 Twitter，还可以从其他著名的社交媒体网络（如 Facebook、Instagram 等）中抓取内容。

它的优点是可以检索的推文数量或推文窗口（即推文的日期范围）没有限制。因此，Snscape 允许您检索旧数据。

但一个缺点是它缺乏 Tweepy 的所有其他功能——不过，如果你只想抓取推文，Snscrap 就足够了。

现在我们已经阐明了这两种方法之间的区别，让我们一一来看看它们的实现。

如何使用 Tweepy 抓取推文

在我们开始使用 Tweepy 之前，我们必须首先确保我们的 Twitter 凭据已准备好。有了它，我们可以将 Tweepy 连接到我们的 API 密钥并开始抓取。

如果您没有 Twitter 凭据，您可以前往此处注册 Twitter 开发者帐户。您将被问及一些关于您打算如何使用 Twitter API 的基本问题。之后，您可以开始实施。

第一步是在你的本地机器上安装 Tweepy 库，你可以通过键入：

pip install git+https://github.com/tweepy/tweepy.git

如何在 Twitter 上抓取用户的推文

现在我们已经安装了 Tweepy 库，让我们从johnTwitter 上调用的用户那里抓取 100 条推文。我们将查看完整的代码实现，让我们这样做并详细讨论它，以便我们了解发生了什么：

import tweepy

consumer_key = "XXXX" #Your API/Consumer key 
consumer_secret = "XXXX" #Your API/Consumer Secret Key
access_token = "XXXX"    #Your Access token key
access_token_secret = "XXXX" #Your Access token Secret key

#Pass in our twitter API authentication key
auth = tweepy.OAuth1UserHandler(
    consumer_key, consumer_secret,
    access_token, access_token_secret
)

#Instantiate the tweepy API
api = tweepy.API(auth, wait_on_rate_limit=True)


username = "john"
no_of_tweets =100


try:
    #The number of tweets we want to retrieved from the user
    tweets = api.user_timeline(screen_name=username, count=no_of_tweets)
    
    #Pulling Some attributes from the tweet
    attributes_container = [[tweet.created_at, tweet.favorite_count,tweet.source,  tweet.text] for tweet in tweets]

    #Creation of column list to rename the columns in the dataframe
    columns = ["Date Created", "Number of Likes", "Source of Tweet", "Tweet"]
    
    #Creation of Dataframe
    tweets_df = pd.DataFrame(attributes_container, columns=columns)
except BaseException as e:
    print('Status Failed On,',str(e))
    time.sleep(3)

现在让我们回顾一下上面代码块中的每一部分代码。

import tweepy

consumer_key = "XXXX" #Your API/Consumer key 
consumer_secret = "XXXX" #Your API/Consumer Secret Key
access_token = "XXXX"    #Your Access token key
access_token_secret = "XXXX" #Your Access token Secret key

#Pass in our twitter API authentication key
auth = tweepy.OAuth1UserHandler(
    consumer_key, consumer_secret,
    access_token, access_token_secret
)

#Instantiate the tweepy API
api = tweepy.API(auth, wait_on_rate_limit=True)

在上面的代码中，我们将 Tweepy 库导入到我们的代码中，然后我们创建了一些变量来存储我们的 Twitter 凭据（Tweepy 身份验证处理程序需要我们的四个 Twitter 凭据）。所以我们然后将这些变量传递给 Tweepy 身份验证处理程序并将它们保存到另一个变量中。

然后最后一个调用语句是我们实例化 Tweepy API 并传入 require 参数的地方。

username = "john"
no_of_tweets =100


try:
    #The number of tweets we want to retrieved from the user
    tweets = api.user_timeline(screen_name=username, count=no_of_tweets)
    
    #Pulling Some attributes from the tweet
    attributes_container = [[tweet.created_at, tweet.favorite_count,tweet.source,  tweet.text] for tweet in tweets]

    #Creation of column list to rename the columns in the dataframe
    columns = ["Date Created", "Number of Likes", "Source of Tweet", "Tweet"]
    
    #Creation of Dataframe
    tweets_df = pd.DataFrame(attributes_container, columns=columns)
except BaseException as e:
    print('Status Failed On,',str(e))

在上面的代码中，我们创建了要从中检索推文的用户名（Twitter 中的@name）以及推文的数量。然后我们创建了一个异常处理程序来帮助我们以更有效的方式捕获错误。

之后，api.user_timeline()返回我们在参数中选择的用户发布的最新推文的集合以及screen_name您要检索的推文数量。

在下一行代码中，我们传入了一些我们想从每条推文中检索的属性，并将它们保存到一个列表中。要查看可以从推文中检索到的更多属性，请阅读此。

在最后一段代码中，我们创建了一个数据框，并传入了我们创建的列表以及我们创建的列的名称。

请注意，列名必须按照您将它们传递到属性容器的顺序（即，当您从推文中检索属性时，您如何在列表中传递这些属性）。

如果你正确地按照我描述的步骤，你应该有这样的：

作者图片

现在我们已经完成了，在我们进入 Snscrap 实现之前，让我们再看一个例子。

如何从文本搜索中抓取推文

在这种方法中，我们将根据搜索检索推文。你可以这样做：

import tweepy

consumer_key = "XXXX" #Your API/Consumer key 
consumer_secret = "XXXX" #Your API/Consumer Secret Key
access_token = "XXXX"    #Your Access token key
access_token_secret = "XXXX" #Your Access token Secret key

#Pass in our twitter API authentication key
auth = tweepy.OAuth1UserHandler(
    consumer_key, consumer_secret,
    access_token, access_token_secret
)

#Instantiate the tweepy API
api = tweepy.API(auth, wait_on_rate_limit=True)


search_query = "sex for grades"
no_of_tweets =150


try:
    #The number of tweets we want to retrieved from the search
    tweets = api.search_tweets(q=search_query, count=no_of_tweets)
    
    #Pulling Some attributes from the tweet
    attributes_container = [[tweet.user.name, tweet.created_at, tweet.favorite_count, tweet.source,  tweet.text] for tweet in tweets]

    #Creation of column list to rename the columns in the dataframe
    columns = ["User", "Date Created", "Number of Likes", "Source of Tweet", "Tweet"]
    
    #Creation of Dataframe
    tweets_df = pd.DataFrame(attributes_container, columns=columns)
except BaseException as e:
    print('Status Failed On,',str(e))

上面的代码与前面的代码类似，只是我们将 API 方法从 更改api.user_timeline()为api.search_tweets()。我们还添加tweet.user.name了属性容器列表。

在上面的代码中，你可以看到我们传入了两个属性。这是因为如果我们只传入tweet.user，它只会返回一个字典用户对象。所以我们还必须传入另一个我们想从用户对象中检索的属性，即name.

您可以在此处查看可以从用户对象中检索的附加属性列表。现在，一旦您运行它，您应该会看到类似这样的内容：

图片由作者提供。

好的，这就是 Tweepy 的实现。请记住，您可以检索的推文数量是有限制的，并且您不能使用 Tweepy 检索超过 7 天的推文。

如何使用 Snscrape 来抓取推文

正如我之前提到的，Snscrape 不需要 Twitter 凭据（API 密钥）来访问它。您可以获取的推文数量也没有限制。

但是，对于这个示例，我们将只检索与上一个示例相同的推文，但使用 Snscape。

要使用 Snscrap，我们必须首先在我们的 PC 上安装它的库。您可以通过键入：

pip3 install git+https://github.com/JustAnotherArchivist/snscrape.git

如何使用 Snscrape 抓取用户的推文

Snscrape 包括两种从 Twitter 获取推文的方法：命令行界面 (CLI) 和 Python Wrapper。请记住，Python Wrapper 目前没有文档记录——但我们仍然可以通过反复试验来度过难关。

在本例中，我们将使用 Python Wrapper，因为它比 CLI 方法更直观。但是，如果您遇到一些代码问题，您可以随时向 GitHub 社区寻求帮助。贡献者将很乐意为您提供帮助。

要检索特定用户的推文，我们可以执行以下操作：

import snscrape.modules.twitter as sntwitter
import pandas as pd

# Created a list to append all tweet attributes(data)
attributes_container = []

# Using TwitterSearchScraper to scrape data and append tweets to list
for i,tweet in enumerate(sntwitter.TwitterSearchScraper('from:john').get_items()):
    if i>100:
        break
    attributes_container.append([tweet.date, tweet.likeCount, tweet.sourceLabel, tweet.content])
    
# Creating a dataframe from the tweets list above 
tweets_df = pd.DataFrame(attributes_container, columns=["Date Created", "Number of Likes", "Source of Tweet", "Tweets"])

让我们复习一下你可能第一眼看不懂的一些代码：

for i,tweet in enumerate(sntwitter.TwitterSearchScraper('from:john').get_items()):
    if i>100:
        break
    attributes_container.append([tweet.date, tweet.likeCount, tweet.sourceLabel, tweet.content])
    
  
# Creating a dataframe from the tweets list above 
tweets_df = pd.DataFrame(attributes_container, columns=["Date Created", "Number of Likes", "Source of Tweet", "Tweets"])

在上面的代码中，所做的sntwitter.TwitterSearchScaper是从我们传递给它的用户名（即 john）中返回一个推文对象。

正如我之前提到的，Snscrape 对推文的数量没有限制，因此它会返回来自该用户的许多推文。为了解决这个问题，我们需要添加枚举函数，该函数将遍历对象并添加一个计数器，以便我们可以访问用户最近的 100 条推文。

您可以看到，我们从每条推文中获得的属性语法与 Tweepy 中的类似。这些是我们可以从 Martin Beck 策划的 Snscape 推文中获得的属性列表。

学分：马丁贝克

可能会添加更多属性，因为 Snscape 库仍在开发中。例如上图中的，source已替换为sourceLabel. 如果你只传入source它会返回一个对象。

如果你运行上面的代码，你应该也会看到类似这样的东西：

作者图片

现在让我们对通过搜索进行抓取做同样的事情。

如何使用 Snscrape 从文本搜索中抓取推文

import snscrape.modules.twitter as sntwitter
import pandas as pd

# Creating list to append tweet data to
attributes_container = []

# Using TwitterSearchScraper to scrape data and append tweets to list
for i,tweet in enumerate(sntwitter.TwitterSearchScraper('sex for grades since:2021-07-05 until:2022-07-06').get_items()):
    if i>150:
        break
    attributes_container.append([tweet.user.username, tweet.date, tweet.likeCount, tweet.sourceLabel, tweet.content])
    
# Creating a dataframe to load the list
tweets_df = pd.DataFrame(attributes_container, columns=["User", "Date Created", "Number of Likes", "Source of Tweet", "Tweet"])

同样，您可以使用 Snscrape 访问大量历史数据（与 Tweepy 不同，因为它的标准 API 不能超过 7 天。高级 API 是 30 天。）。所以我们可以在方法中传入我们想要开始搜索的日期和想要结束的日期sntwitter.TwitterSearchScraper()。

我们在前面的代码中所做的基本上就是我们之前讨论过的。唯一要记住的是，直到与 Python 中的范围函数类似（也就是说，它不包括最后一个整数）。因此，如果您想从今天开始获取推文，则需要在“直到”参数中包含今天之后的一天。

作者的形象。

现在您也知道如何使用 Snscape 抓取推文了！

何时使用每种方法

现在我们已经了解了每种方法的工作原理，您可能想知道何时使用哪种方法。

好吧，对于何时使用每种方法没有通用规则。一切都取决于问题偏好和您的用例。

如果你想获得无穷无尽的推文，你应该使用 Snscrap。但是，如果您想使用 Snscrape 无法提供的额外功能（例如地理定位），那么您绝对应该使用 Tweepy。它直接与 Twitter API 集成并提供完整的功能。

即便如此，Snscrape 是最常用的基本刮削方法。

结论

在本文中，我们学习了如何使用 Tweepy 和 Snscrap 从 Python 中抓取数据。但这只是对每种方法如何工作的简要概述。您可以通过浏览网络了解更多信息以获取更多信息。

我提供了一些有用的资源，如果您需要更多信息，可以使用它们。感谢您的阅读。

 来源：https ://www.freecodecamp.org/news/python-web-scraping-tutorial/

#python #web 

Como Extrair Dados Do Twitter Usando Tweepy E Snscrape

Se você é um entusiasta de dados, provavelmente concordará que uma das fontes mais ricas de dados do mundo real são as mídias sociais. Sites como o Twitter estão cheios de dados.

Você pode usar os dados obtidos nas mídias sociais de várias maneiras, como análise de sentimentos (analisando os pensamentos das pessoas) sobre um assunto ou campo de interesse específico.

Existem várias maneiras de extrair (ou coletar) dados do Twitter. E neste artigo, veremos duas dessas maneiras: usando o Tweepy e o Snscrape.

Aprenderemos um método para extrair conversas públicas de pessoas sobre um tópico de tendência específico, bem como tweets de um usuário específico.

Agora sem mais delongas, vamos começar.

Tweepy vs Snscrape – Introdução às nossas ferramentas de raspagem

Agora, antes de entrarmos na implementação de cada plataforma, vamos tentar entender as diferenças e os limites de cada plataforma.

Tweepy

Tweepy é uma biblioteca Python para integração com a API do Twitter. Como o Tweepy está conectado à API do Twitter, você pode realizar consultas complexas além de extrair tweets. Ele permite que você aproveite todos os recursos da API do Twitter.

Mas existem algumas desvantagens – como o fato de que sua API padrão só permite coletar tweets por até uma semana (ou seja, o Tweepy não permite a recuperação de tweets além de uma janela de semana, portanto, a recuperação de dados históricos não é permitida).

Além disso, há limites para quantos tweets você pode recuperar da conta de um usuário. Você pode ler mais sobre as funcionalidades do Tweepy aqui .

Snscrape

Snscrape é outra abordagem para extrair informações do Twitter que não requer o uso de uma API. O Snscrape permite extrair informações básicas, como o perfil de um usuário, conteúdo do tweet, fonte e assim por diante.

O Snscrape não se limita ao Twitter, mas também pode extrair conteúdo de outras redes sociais proeminentes, como Facebook, Instagram e outros.

Suas vantagens são que não há limites para o número de tweets que você pode recuperar ou a janela de tweets (ou seja, o intervalo de datas dos tweets). Então Snscrape permite que você recupere dados antigos.

Mas a única desvantagem é que ele não possui todas as outras funcionalidades do Tweepy – ainda assim, se você quiser apenas raspar tweets, o Snscrape seria suficiente.

Agora que esclarecemos a distinção entre os dois métodos, vamos analisar sua implementação um por um.

Como usar o Tweepy para raspar tweets

Antes de começarmos a usar o Tweepy, devemos primeiro ter certeza de que nossas credenciais do Twitter estão prontas. Com isso, podemos conectar o Tweepy à nossa chave de API e começar a raspar.

Se você não tiver credenciais do Twitter, poderá se registrar para uma conta de desenvolvedor do Twitter acessando aqui . Serão feitas algumas perguntas básicas sobre como você pretende usar a API do Twitter. Depois disso, você pode começar a implementação.

O primeiro passo é instalar a biblioteca Tweepy em sua máquina local, o que você pode fazer digitando:

pip install git+https://github.com/tweepy/tweepy.git

Como raspar tweets de um usuário no Twitter

Agora que instalamos a biblioteca Tweepy, vamos extrair 100 tweets de um usuário chamado johnno Twitter. Veremos a implementação completa do código que nos permitirá fazer isso e discutiremos em detalhes para que possamos entender o que está acontecendo:

import tweepy

consumer_key = "XXXX" #Your API/Consumer key 
consumer_secret = "XXXX" #Your API/Consumer Secret Key
access_token = "XXXX"    #Your Access token key
access_token_secret = "XXXX" #Your Access token Secret key

#Pass in our twitter API authentication key
auth = tweepy.OAuth1UserHandler(
    consumer_key, consumer_secret,
    access_token, access_token_secret
)

#Instantiate the tweepy API
api = tweepy.API(auth, wait_on_rate_limit=True)


username = "john"
no_of_tweets =100


try:
    #The number of tweets we want to retrieved from the user
    tweets = api.user_timeline(screen_name=username, count=no_of_tweets)
    
    #Pulling Some attributes from the tweet
    attributes_container = [[tweet.created_at, tweet.favorite_count,tweet.source,  tweet.text] for tweet in tweets]

    #Creation of column list to rename the columns in the dataframe
    columns = ["Date Created", "Number of Likes", "Source of Tweet", "Tweet"]
    
    #Creation of Dataframe
    tweets_df = pd.DataFrame(attributes_container, columns=columns)
except BaseException as e:
    print('Status Failed On,',str(e))
    time.sleep(3)

Agora vamos examinar cada parte do código no bloco acima.

import tweepy

consumer_key = "XXXX" #Your API/Consumer key 
consumer_secret = "XXXX" #Your API/Consumer Secret Key
access_token = "XXXX"    #Your Access token key
access_token_secret = "XXXX" #Your Access token Secret key

#Pass in our twitter API authentication key
auth = tweepy.OAuth1UserHandler(
    consumer_key, consumer_secret,
    access_token, access_token_secret
)

#Instantiate the tweepy API
api = tweepy.API(auth, wait_on_rate_limit=True)

No código acima, importamos a biblioteca Tweepy para nosso código e criamos algumas variáveis ​​nas quais armazenamos nossas credenciais do Twitter (o manipulador de autenticação do Tweepy requer quatro de nossas credenciais do Twitter). Então, passamos essas variáveis ​​para o manipulador de autenticação Tweepy e as salvamos em outra variável.

Em seguida, a última instrução de chamada é onde instanciamos a API do Tweepy e passamos os parâmetros require.

username = "john"
no_of_tweets =100


try:
    #The number of tweets we want to retrieved from the user
    tweets = api.user_timeline(screen_name=username, count=no_of_tweets)
    
    #Pulling Some attributes from the tweet
    attributes_container = [[tweet.created_at, tweet.favorite_count,tweet.source,  tweet.text] for tweet in tweets]

    #Creation of column list to rename the columns in the dataframe
    columns = ["Date Created", "Number of Likes", "Source of Tweet", "Tweet"]
    
    #Creation of Dataframe
    tweets_df = pd.DataFrame(attributes_container, columns=columns)
except BaseException as e:
    print('Status Failed On,',str(e))

No código acima, criamos o nome do usuário (o @name no Twitter) do qual queremos recuperar os tweets e também o número de tweets. Em seguida, criamos um manipulador de exceção para nos ajudar a detectar erros de maneira mais eficaz.

Depois disso, o api.user_timeline()retorna uma coleção dos tweets mais recentes postados pelo usuário que escolhemos no screen_nameparâmetro e o número de tweets que você deseja recuperar.

Na próxima linha de código, passamos alguns atributos que queremos recuperar de cada tweet e os salvamos em uma lista. Para ver mais atributos que você pode recuperar de um tweet, leia isto .

No último pedaço de código criamos um dataframe e passamos a lista que criamos junto com os nomes da coluna que criamos.

Observe que os nomes das colunas devem estar na sequência de como você os passou para o contêiner de atributos (ou seja, como você passou esses atributos em uma lista quando estava recuperando os atributos do tweet).

Se você seguiu corretamente os passos que descrevi, você deve ter algo assim:

Imagem do autor

Agora que terminamos, vamos ver mais um exemplo antes de passarmos para a implementação do Snscrape.

Como raspar tweets de uma pesquisa de texto

Neste método, estaremos recuperando um tweet com base em uma pesquisa. Você pode fazer assim:

import tweepy

consumer_key = "XXXX" #Your API/Consumer key 
consumer_secret = "XXXX" #Your API/Consumer Secret Key
access_token = "XXXX"    #Your Access token key
access_token_secret = "XXXX" #Your Access token Secret key

#Pass in our twitter API authentication key
auth = tweepy.OAuth1UserHandler(
    consumer_key, consumer_secret,
    access_token, access_token_secret
)

#Instantiate the tweepy API
api = tweepy.API(auth, wait_on_rate_limit=True)


search_query = "sex for grades"
no_of_tweets =150


try:
    #The number of tweets we want to retrieved from the search
    tweets = api.search_tweets(q=search_query, count=no_of_tweets)
    
    #Pulling Some attributes from the tweet
    attributes_container = [[tweet.user.name, tweet.created_at, tweet.favorite_count, tweet.source,  tweet.text] for tweet in tweets]

    #Creation of column list to rename the columns in the dataframe
    columns = ["User", "Date Created", "Number of Likes", "Source of Tweet", "Tweet"]
    
    #Creation of Dataframe
    tweets_df = pd.DataFrame(attributes_container, columns=columns)
except BaseException as e:
    print('Status Failed On,',str(e))

O código acima é semelhante ao código anterior, exceto que alteramos o método da API de api.user_timeline()para api.search_tweets(). Também adicionamos tweet.user.nameà lista de contêineres de atributos.

No código acima, você pode ver que passamos dois atributos. Isso ocorre porque se passarmos apenas tweet.user, ele retornaria apenas um objeto de usuário de dicionário. Portanto, também devemos passar outro atributo que queremos recuperar do objeto de usuário, que é name.

Você pode acessar aqui para ver uma lista de atributos adicionais que podem ser recuperados de um objeto de usuário. Agora você deve ver algo assim depois de executá-lo:

Imagem do Autor.

Tudo bem, isso praticamente encerra a implementação do Tweepy. Apenas lembre-se de que há um limite para o número de tweets que você pode recuperar, e você não pode recuperar tweets com mais de 7 dias usando o Tweepy.

Como usar o Snscrape para raspar tweets

Como mencionei anteriormente, o Snscrape não requer credenciais do Twitter (chave de API) para acessá-lo. Também não há limite para o número de tweets que você pode buscar.

Para este exemplo, porém, apenas recuperaremos os mesmos tweets do exemplo anterior, mas usando o Snscrape.

Para usar o Snscrape, devemos primeiro instalar sua biblioteca em nosso PC. Você pode fazer isso digitando:

pip3 install git+https://github.com/JustAnotherArchivist/snscrape.git

Como raspar tweets de um usuário com Snscrape

O Snscrape inclui dois métodos para obter tweets do Twitter: a interface de linha de comando (CLI) e um Python Wrapper. Apenas tenha em mente que o Python Wrapper não está documentado no momento – mas ainda podemos nos virar com tentativa e erro.

Neste exemplo, usaremos o Python Wrapper porque é mais intuitivo que o método CLI. Mas se você ficar preso a algum código, sempre poderá recorrer à comunidade do GitHub para obter assistência. Os colaboradores terão prazer em ajudá-lo.

Para recuperar tweets de um usuário específico, podemos fazer o seguinte:

import snscrape.modules.twitter as sntwitter
import pandas as pd

# Created a list to append all tweet attributes(data)
attributes_container = []

# Using TwitterSearchScraper to scrape data and append tweets to list
for i,tweet in enumerate(sntwitter.TwitterSearchScraper('from:john').get_items()):
    if i>100:
        break
    attributes_container.append([tweet.date, tweet.likeCount, tweet.sourceLabel, tweet.content])
    
# Creating a dataframe from the tweets list above 
tweets_df = pd.DataFrame(attributes_container, columns=["Date Created", "Number of Likes", "Source of Tweet", "Tweets"])

Vamos revisar alguns dos códigos que você pode não entender à primeira vista:

for i,tweet in enumerate(sntwitter.TwitterSearchScraper('from:john').get_items()):
    if i>100:
        break
    attributes_container.append([tweet.date, tweet.likeCount, tweet.sourceLabel, tweet.content])
    
  
# Creating a dataframe from the tweets list above 
tweets_df = pd.DataFrame(attributes_container, columns=["Date Created", "Number of Likes", "Source of Tweet", "Tweets"])

No código acima, o que o sntwitter.TwitterSearchScaperfaz é retornar um objeto de tweets do nome do usuário que passamos para ele (que é john).

Como mencionei anteriormente, o Snscrape não tem limites no número de tweets, então ele retornará quantos tweets desse usuário. Para ajudar com isso, precisamos adicionar a função enumerate que irá percorrer o objeto e adicionar um contador para que possamos acessar os 100 tweets mais recentes do usuário.

Você pode ver que a sintaxe de atributos que obtemos de cada tweet se parece com a do Tweepy. Esta é a lista de atributos que podemos obter do tweet do Snscrape, com curadoria de Martin Beck.

Crédito: Martin Beck

Mais atributos podem ser adicionados, pois a biblioteca Snscrape ainda está em desenvolvimento. Como por exemplo na imagem acima, sourcefoi substituído por sourceLabel. Se você passar apenas sourceele retornará um objeto.

Se você executar o código acima, deverá ver algo assim também:

Imagem do autor

Agora vamos fazer o mesmo para raspagem por pesquisa.

Como raspar tweets de uma pesquisa de texto com Snscrape

import snscrape.modules.twitter as sntwitter
import pandas as pd

# Creating list to append tweet data to
attributes_container = []

# Using TwitterSearchScraper to scrape data and append tweets to list
for i,tweet in enumerate(sntwitter.TwitterSearchScraper('sex for grades since:2021-07-05 until:2022-07-06').get_items()):
    if i>150:
        break
    attributes_container.append([tweet.user.username, tweet.date, tweet.likeCount, tweet.sourceLabel, tweet.content])
    
# Creating a dataframe to load the list
tweets_df = pd.DataFrame(attributes_container, columns=["User", "Date Created", "Number of Likes", "Source of Tweet", "Tweet"])

Novamente, você pode acessar muitos dados históricos usando o Snscrape (ao contrário do Tweepy, pois sua API padrão não pode exceder 7 dias. A API premium é de 30 dias). Assim, podemos passar a data a partir da qual queremos iniciar a pesquisa e a data em que queremos que ela termine no sntwitter.TwitterSearchScraper()método.

O que fizemos no código anterior é basicamente o que discutimos antes. A única coisa a ter em mente é que até funciona de forma semelhante à função range em Python (ou seja, exclui o último inteiro). Portanto, se você deseja obter tweets de hoje, precisa incluir o dia depois de hoje no parâmetro "até".

Imagem do Autor.

Agora você também sabe como raspar tweets com o Snscrape!

Quando usar cada abordagem

Agora que vimos como cada método funciona, você deve estar se perguntando quando usar qual.

Bem, não existe uma regra universal para quando utilizar cada método. Tudo se resume a uma preferência de assunto e seu caso de uso.

Se você deseja adquirir um número infinito de tweets, deve usar o Snscrape. Mas se você quiser usar recursos extras que o Snscrape não pode fornecer (como geolocalização, por exemplo), você deve definitivamente usar o Tweepy. Ele é integrado diretamente com a API do Twitter e oferece funcionalidade completa.

Mesmo assim, o Snscrape é o método mais comumente usado para raspagem básica.

Conclusão

Neste artigo, aprendemos como extrair dados do Python usando Tweepy e Snscrape. Mas esta foi apenas uma breve visão geral de como cada abordagem funciona. Você pode aprender mais explorando a web para obter informações adicionais.

Incluí alguns recursos úteis que você pode usar se precisar de informações adicionais. Obrigado por ler.

 Fonte: https://www.freecodecamp.org/news/python-web-scraping-tutorial/ 

#python #web